diff --git a/WORKSPACE b/WORKSPACE
index eee3d96..2eba07b 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -58,6 +58,14 @@
     "//debian:opencv_amd64.bzl",
     opencv_amd64_debs = "files",
 )
+load(
+    "//debian:gstreamer_amd64.bzl",
+    gstreamer_amd64_debs = "files"
+)
+load(
+    "//debian:gstreamer_armhf.bzl",
+    gstreamer_armhf_debs = "files"
+)
 load("//debian:packages.bzl", "generate_repositories_for_debs")
 
 generate_repositories_for_debs(python_debs)
@@ -88,6 +96,10 @@
 
 generate_repositories_for_debs(opencv_amd64_debs)
 
+generate_repositories_for_debs(gstreamer_amd64_debs)
+
+generate_repositories_for_debs(gstreamer_armhf_debs)
+
 http_archive(
     name = "python_repo",
     build_file = "@//debian:python.BUILD",
@@ -692,3 +704,17 @@
     type = "zip",
     url = "http://www.frc971.org/Build-Dependencies/opencv_contrib_python_nonfree-4.1.1.1-cp35-cp35m-manylinux1_x86_64.whl",
 )
+
+http_archive(
+    name = "gstreamer_k8",
+    build_file = "@//debian:gstreamer.BUILD",
+    sha256 = "4d74d4a82f7a73dc9fe9463d5fae409b17845eef7cd64ef9c4c4553816c53589",
+    url = "http://www.frc971.org/Build-Dependencies/gstreamer_amd64.tar.gz",
+)
+
+http_archive(
+    name = "gstreamer_armhf",
+    build_file = "@//debian:gstreamer.BUILD",
+    sha256 = "c5ac4c604952c274a50636e244f0d091bd1de302032446f24f0e9e03ae9c76f7",
+    url = "http://www.frc971.org/Build-Dependencies/gstreamer_armhf.tar.gz",
+)
diff --git a/aos/events/BUILD b/aos/events/BUILD
index a905728..d35f206 100644
--- a/aos/events/BUILD
+++ b/aos/events/BUILD
@@ -64,6 +64,7 @@
         "event_loop_tmpl.h",
     ],
     hdrs = [
+        "channel_preallocated_allocator.h",
         "event_loop.h",
     ],
     visibility = ["//visibility:public"],
diff --git a/aos/events/channel_preallocated_allocator.h b/aos/events/channel_preallocated_allocator.h
new file mode 100644
index 0000000..8a5d68f
--- /dev/null
+++ b/aos/events/channel_preallocated_allocator.h
@@ -0,0 +1,77 @@
+#ifndef AOS_EVENTS_CHANNEL_PREALLOCATED_ALLOCATOR_
+#define AOS_EVENTS_CHANNEL_PREALLOCATED_ALLOCATOR_
+
+#include "aos/configuration.h"
+#include "aos/configuration_generated.h"
+#include "flatbuffers/flatbuffers.h"
+
+namespace aos {
+
+class ChannelPreallocatedAllocator : public flatbuffers::Allocator {
+ public:
+  ChannelPreallocatedAllocator(uint8_t *data, size_t size,
+                               const Channel *channel)
+      : data_(data), size_(size), channel_(channel) {}
+
+  ChannelPreallocatedAllocator(const ChannelPreallocatedAllocator &) = delete;
+  ChannelPreallocatedAllocator(ChannelPreallocatedAllocator &&other)
+      : data_(other.data_), size_(other.size_), channel_(other.channel_) {
+    CHECK(!is_allocated());
+    CHECK(!other.is_allocated());
+  }
+
+  ChannelPreallocatedAllocator &operator=(
+      const ChannelPreallocatedAllocator &) = delete;
+  ChannelPreallocatedAllocator &operator=(
+      ChannelPreallocatedAllocator &&other) {
+    CHECK(!is_allocated());
+    CHECK(!other.is_allocated());
+    data_ = other.data_;
+    size_ = other.size_;
+    channel_ = other.channel_;
+    return *this;
+  }
+  ~ChannelPreallocatedAllocator() override { CHECK(!is_allocated_); }
+
+  // TODO(austin): Read the contract for these.
+  uint8_t *allocate(size_t /*size*/) override {
+    if (is_allocated_) {
+      LOG(FATAL) << "Can't allocate more memory with a fixed size allocator.  "
+                    "Increase the memory reserved.";
+    }
+
+    is_allocated_ = true;
+    return data_;
+  }
+
+  void deallocate(uint8_t *, size_t) override { is_allocated_ = false; }
+
+  uint8_t *reallocate_downward(uint8_t * /*old_p*/, size_t /*old_size*/,
+                               size_t new_size, size_t /*in_use_back*/,
+                               size_t /*in_use_front*/) override {
+    LOG(FATAL) << "Requested " << new_size << " bytes, max size "
+               << channel_->max_size() << " for channel "
+               << configuration::CleanedChannelToString(channel_)
+               << ".  Increase the memory reserved to at least " << new_size
+               << ".";
+    return nullptr;
+  }
+
+  void Reset() { is_allocated_ = false; }
+  bool is_allocated() const { return is_allocated_; }
+
+  bool allocated() { return is_allocated_; }
+
+  size_t size() const { return size_; }
+  const uint8_t *data() const { return data_; }
+
+ private:
+  bool is_allocated_ = false;
+  uint8_t *data_;
+  size_t size_;
+  const Channel *channel_;
+};
+
+}  // namespace aos
+
+#endif  // AOS_EVENTS_CHANNEL_PREALLOCATED_ALLOCATOR_
diff --git a/aos/events/event_loop.h b/aos/events/event_loop.h
index d0ca196..bc5a5ae 100644
--- a/aos/events/event_loop.h
+++ b/aos/events/event_loop.h
@@ -1,5 +1,4 @@
 #ifndef AOS_EVENTS_EVENT_LOOP_H_
-
 #define AOS_EVENTS_EVENT_LOOP_H_
 
 #include <atomic>
@@ -8,6 +7,7 @@
 
 #include "aos/configuration.h"
 #include "aos/configuration_generated.h"
+#include "aos/events/channel_preallocated_allocator.h"
 #include "aos/events/event_loop_event.h"
 #include "aos/events/event_loop_generated.h"
 #include "aos/events/timing_statistics.h"
@@ -145,8 +145,9 @@
 
   // Returns the associated flatbuffers-style allocator. This must be
   // deallocated before the message is sent.
-  PreallocatedAllocator *fbb_allocator() {
-    fbb_allocator_ = PreallocatedAllocator(data(), size());
+  ChannelPreallocatedAllocator *fbb_allocator() {
+    fbb_allocator_ = ChannelPreallocatedAllocator(
+        reinterpret_cast<uint8_t *>(data()), size(), channel());
     return &fbb_allocator_;
   }
 
@@ -176,7 +177,7 @@
 
   internal::RawSenderTiming timing_;
 
-  PreallocatedAllocator fbb_allocator_{nullptr, 0};
+  ChannelPreallocatedAllocator fbb_allocator_{nullptr, 0, nullptr};
 };
 
 // Fetches the newest message from a channel.
@@ -247,7 +248,7 @@
   // builder.Send(t_builder.Finish());
   class Builder {
    public:
-    Builder(RawSender *sender, PreallocatedAllocator *allocator)
+    Builder(RawSender *sender, ChannelPreallocatedAllocator *allocator)
         : fbb_(allocator->size(), allocator),
           allocator_(allocator),
           sender_(sender) {
@@ -283,7 +284,7 @@
 
    private:
     flatbuffers::FlatBufferBuilder fbb_;
-    PreallocatedAllocator *allocator_;
+    ChannelPreallocatedAllocator *allocator_;
     RawSender *sender_;
   };
 
@@ -302,9 +303,7 @@
   // Returns the name of the underlying queue.
   const Channel *channel() const { return sender_->channel(); }
 
-  operator bool() {
-    return sender_ ? true : false;
-  }
+  operator bool() { return sender_ ? true : false; }
 
   // Returns the time_points that the last message was sent at.
   aos::monotonic_clock::time_point monotonic_sent_time() const {
@@ -464,13 +463,33 @@
 
   // This will watch messages sent to the provided channel.
   //
-  // Watch is a functor that have a call signature like so:
-  // void Event(const MessageType& type);
+  // w must have a non-polymorphic operator() (aka it can only be called with a
+  // single set of arguments; no overloading or templates). It must be callable
+  // with this signature:
+  //   void(const MessageType &);
   //
-  // TODO(parker): Need to support ::std::bind.  For now, use lambdas.
-  // TODO(austin): Do we need a functor?  Or is a std::function good enough?
+  // Lambdas are a common form for w. A std::function will work too.
+  //
+  // Note that bind expressions have polymorphic call operators, so they are not
+  // allowed.
+  //
+  // We template Watch as a whole instead of using std::function<void(const T
+  // &)> to allow deducing MessageType from lambdas and other things which are
+  // implicitly convertible to std::function, but not actually std::function
+  // instantiations. Template deduction guides might allow solving this
+  // differently in newer versions of C++, but those have their own corner
+  // cases.
   template <typename Watch>
-  void MakeWatcher(const std::string_view name, Watch &&w);
+  void MakeWatcher(const std::string_view channel_name, Watch &&w);
+
+  // Like MakeWatcher, but doesn't have access to the message data. This may be
+  // implemented to use less resources than an equivalent MakeWatcher.
+  //
+  // The function will still have access to context(), although that will have
+  // its data field set to nullptr.
+  template <typename MessageType>
+  void MakeNoArgWatcher(const std::string_view channel_name,
+                        std::function<void()> w);
 
   // The passed in function will be called when the event loop starts.
   // Use this to run code once the thread goes into "real-time-mode",
@@ -518,6 +537,18 @@
       std::function<void(const Context &context, const void *message)>
           watcher) = 0;
 
+  // Watches channel (name, type) for new messages, without needing to extract
+  // the message contents. Default implementation simply re-uses MakeRawWatcher.
+  virtual void MakeRawNoArgWatcher(
+      const Channel *channel,
+      std::function<void(const Context &context)> watcher) {
+    MakeRawWatcher(channel, [watcher](const Context &context, const void *) {
+      Context new_context = context;
+      new_context.data = nullptr;
+      watcher(new_context);
+    });
+  }
+
   // Creates a raw sender for the provided channel.  This is used for reflection
   // based sending.
   // Note: this ignores any node constraints.  Ignore at your own peril.
diff --git a/aos/events/event_loop_param_test.cc b/aos/events/event_loop_param_test.cc
index 096d84a..f0fb3d3 100644
--- a/aos/events/event_loop_param_test.cc
+++ b/aos/events/event_loop_param_test.cc
@@ -43,6 +43,94 @@
   EXPECT_TRUE(happened);
 }
 
+// Verifies that a no-arg watcher will not have a data pointer.
+TEST_P(AbstractEventLoopTest, NoArgNoData) {
+  auto loop1 = Make();
+  auto loop2 = MakePrimary();
+
+  aos::Sender<TestMessage> sender = loop1->MakeSender<TestMessage>("/test");
+
+  bool happened = false;
+
+  loop2->OnRun([&]() {
+    happened = true;
+
+    aos::Sender<TestMessage>::Builder msg = sender.MakeBuilder();
+    TestMessage::Builder builder = msg.MakeBuilder<TestMessage>();
+    ASSERT_TRUE(msg.Send(builder.Finish()));
+  });
+
+  loop2->MakeNoArgWatcher<TestMessage>("/test", [&]() {
+    EXPECT_GT(loop2->context().size, 0u);
+    EXPECT_EQ(nullptr, loop2->context().data);
+    this->Exit();
+  });
+
+  EXPECT_FALSE(happened);
+  Run();
+  EXPECT_TRUE(happened);
+}
+
+// Tests that no-arg watcher can receive messages from a sender.
+// Also tests that OnRun() works.
+TEST_P(AbstractEventLoopTest, BasicNoArg) {
+  auto loop1 = Make();
+  auto loop2 = MakePrimary();
+
+  aos::Sender<TestMessage> sender = loop1->MakeSender<TestMessage>("/test");
+
+  bool happened = false;
+
+  loop2->OnRun([&]() {
+    happened = true;
+
+    aos::Sender<TestMessage>::Builder msg = sender.MakeBuilder();
+    TestMessage::Builder builder = msg.MakeBuilder<TestMessage>();
+    builder.add_value(200);
+    ASSERT_TRUE(msg.Send(builder.Finish()));
+  });
+
+  aos::Fetcher<TestMessage> fetcher = loop2->MakeFetcher<TestMessage>("/test");
+  loop2->MakeNoArgWatcher<TestMessage>("/test", [&]() {
+    ASSERT_TRUE(fetcher.Fetch());
+    EXPECT_EQ(fetcher->value(), 200);
+    this->Exit();
+  });
+
+  EXPECT_FALSE(happened);
+  Run();
+  EXPECT_TRUE(happened);
+}
+
+// Tests that a watcher can be created with an std::function.
+TEST_P(AbstractEventLoopTest, BasicFunction) {
+  auto loop1 = Make();
+  auto loop2 = MakePrimary();
+
+  aos::Sender<TestMessage> sender = loop1->MakeSender<TestMessage>("/test");
+
+  bool happened = false;
+
+  loop2->OnRun([&]() {
+    happened = true;
+
+    aos::Sender<TestMessage>::Builder msg = sender.MakeBuilder();
+    TestMessage::Builder builder = msg.MakeBuilder<TestMessage>();
+    builder.add_value(200);
+    ASSERT_TRUE(msg.Send(builder.Finish()));
+  });
+
+  loop2->MakeWatcher("/test", std::function<void(const TestMessage &)>(
+                                  [&](const TestMessage &message) {
+                                    EXPECT_EQ(message.value(), 200);
+                                    this->Exit();
+                                  }));
+
+  EXPECT_FALSE(happened);
+  Run();
+  EXPECT_TRUE(happened);
+}
+
 // Tests that watcher can receive messages from two senders.
 // Also tests that OnRun() works.
 TEST_P(AbstractEventLoopTest, BasicTwoSenders) {
@@ -463,6 +551,9 @@
   EXPECT_DEATH(
       { loop->MakeWatcher("/test/invalid", [&](const TestMessage &) {}); },
       "/test/invalid");
+  EXPECT_DEATH(
+      { loop->MakeNoArgWatcher<TestMessage>("/test/invalid", [&]() {}); },
+      "/test/invalid");
 }
 
 // Verify that registering a watcher twice for "/test" fails.
@@ -471,6 +562,16 @@
   loop->MakeWatcher("/test", [&](const TestMessage &) {});
   EXPECT_DEATH(loop->MakeWatcher("/test", [&](const TestMessage &) {}),
                "/test");
+  EXPECT_DEATH(loop->MakeNoArgWatcher<TestMessage>("/test", [&]() {}), "/test");
+}
+
+// Verify that registering a no-arg watcher twice for "/test" fails.
+TEST_P(AbstractEventLoopDeathTest, TwoNoArgWatcher) {
+  auto loop = Make();
+  loop->MakeNoArgWatcher<TestMessage>("/test", [&]() {});
+  EXPECT_DEATH(loop->MakeWatcher("/test", [&](const TestMessage &) {}),
+               "/test");
+  EXPECT_DEATH(loop->MakeNoArgWatcher<TestMessage>("/test", [&]() {}), "/test");
 }
 
 // Verify that SetRuntimeRealtimePriority fails while running.
@@ -512,6 +613,16 @@
   EXPECT_DEATH(Run(), "running");
 }
 
+// Verify that we can't create a no-arg watcher inside OnRun.
+TEST_P(AbstractEventLoopDeathTest, NoArgWatcherInOnRun) {
+  auto loop1 = MakePrimary();
+
+  loop1->OnRun(
+      [&]() { loop1->MakeNoArgWatcher<TestMessage>("/test", [&]() {}); });
+
+  EXPECT_DEATH(Run(), "running");
+}
+
 // Verify that Quit() works when there are multiple watchers.
 TEST_P(AbstractEventLoopTest, MultipleWatcherQuit) {
   auto loop1 = Make();
@@ -722,7 +833,7 @@
       "Channel pointer not found in configuration\\(\\)->channels\\(\\)");
 }
 
-// Verify that the send time on a message is roughly right.
+// Verify that the send time on a message is roughly right when using a watcher.
 TEST_P(AbstractEventLoopTest, MessageSendTime) {
   auto loop1 = MakePrimary();
   auto loop2 = Make();
@@ -737,7 +848,7 @@
   });
 
   bool triggered = false;
-  loop1->MakeWatcher("/test", [&triggered, &loop1](const TestMessage &msg) {
+  loop1->MakeWatcher("/test", [&](const TestMessage &msg) {
     // Confirm that the data pointer makes sense from a watcher, and all the
     // timestamps look right.
     EXPECT_GT(&msg, loop1->context().data);
@@ -770,7 +881,92 @@
 
   EXPECT_TRUE(triggered);
 
-  EXPECT_TRUE(fetcher.Fetch());
+  ASSERT_TRUE(fetcher.Fetch());
+
+  monotonic_clock::duration monotonic_time_offset =
+      fetcher.context().monotonic_event_time -
+      (loop1->monotonic_now() - ::std::chrono::seconds(1));
+  realtime_clock::duration realtime_time_offset =
+      fetcher.context().realtime_event_time -
+      (loop1->realtime_now() - ::std::chrono::seconds(1));
+
+  EXPECT_EQ(fetcher.context().realtime_event_time,
+            fetcher.context().realtime_remote_time);
+  EXPECT_EQ(fetcher.context().monotonic_event_time,
+            fetcher.context().monotonic_remote_time);
+
+  EXPECT_TRUE(monotonic_time_offset > ::std::chrono::milliseconds(-500))
+      << ": Got "
+      << fetcher.context().monotonic_event_time.time_since_epoch().count()
+      << " expected " << loop1->monotonic_now().time_since_epoch().count();
+  // Confirm that the data pointer makes sense.
+  EXPECT_GT(fetcher.get(), fetcher.context().data);
+  EXPECT_LT(fetcher.get(),
+            reinterpret_cast<void *>(
+                reinterpret_cast<char *>(fetcher.context().data) +
+                fetcher.context().size));
+  EXPECT_TRUE(monotonic_time_offset < ::std::chrono::milliseconds(500))
+      << ": Got "
+      << fetcher.context().monotonic_event_time.time_since_epoch().count()
+      << " expected " << loop1->monotonic_now().time_since_epoch().count();
+
+  EXPECT_TRUE(realtime_time_offset > ::std::chrono::milliseconds(-500))
+      << ": Got "
+      << fetcher.context().realtime_event_time.time_since_epoch().count()
+      << " expected " << loop1->realtime_now().time_since_epoch().count();
+  EXPECT_TRUE(realtime_time_offset < ::std::chrono::milliseconds(500))
+      << ": Got "
+      << fetcher.context().realtime_event_time.time_since_epoch().count()
+      << " expected " << loop1->realtime_now().time_since_epoch().count();
+}
+
+// Verify that the send time on a message is roughly right when using a no-arg
+// watcher. To get a message, we need to use a fetcher to actually access the
+// message. This is also the main use case for no-arg fetchers.
+TEST_P(AbstractEventLoopTest, MessageSendTimeNoArg) {
+  auto loop1 = MakePrimary();
+  auto loop2 = Make();
+  auto sender = loop2->MakeSender<TestMessage>("/test");
+  auto fetcher = loop1->MakeFetcher<TestMessage>("/test");
+
+  auto test_timer = loop1->AddTimer([&sender]() {
+    aos::Sender<TestMessage>::Builder msg = sender.MakeBuilder();
+    TestMessage::Builder builder = msg.MakeBuilder<TestMessage>();
+    builder.add_value(200);
+    ASSERT_TRUE(msg.Send(builder.Finish()));
+  });
+
+  bool triggered = false;
+  loop1->MakeNoArgWatcher<TestMessage>("/test", [&]() {
+    // Confirm that we can indeed use a fetcher on this channel from this
+    // context, and it results in a sane data pointer and timestamps.
+    ASSERT_TRUE(fetcher.Fetch());
+
+    EXPECT_EQ(loop1->context().monotonic_remote_time,
+              loop1->context().monotonic_event_time);
+    EXPECT_EQ(loop1->context().realtime_remote_time,
+              loop1->context().realtime_event_time);
+
+    const aos::monotonic_clock::time_point monotonic_now =
+        loop1->monotonic_now();
+    const aos::realtime_clock::time_point realtime_now = loop1->realtime_now();
+
+    EXPECT_LE(loop1->context().monotonic_event_time, monotonic_now);
+    EXPECT_LE(loop1->context().realtime_event_time, realtime_now);
+    EXPECT_GE(loop1->context().monotonic_event_time + chrono::milliseconds(500),
+              monotonic_now);
+    EXPECT_GE(loop1->context().realtime_event_time + chrono::milliseconds(500),
+              realtime_now);
+
+    triggered = true;
+  });
+
+  test_timer->Setup(loop1->monotonic_now() + ::std::chrono::seconds(1));
+
+  EndEventLoop(loop1.get(), ::std::chrono::seconds(2));
+  Run();
+
+  ASSERT_TRUE(triggered);
 
   monotonic_clock::duration monotonic_time_offset =
       fetcher.context().monotonic_event_time -
@@ -1336,6 +1532,19 @@
       [](const Context &, const void *) {});
 }
 
+// Tests that no-arg watchers work with a node setup.
+TEST_P(AbstractEventLoopTest, NodeNoArgWatcher) {
+  EnableNodes("me");
+
+  auto loop1 = Make();
+  auto loop2 = Make();
+  loop1->MakeWatcher("/test", [](const TestMessage &) {});
+  loop2->MakeRawNoArgWatcher(
+      configuration::GetChannel(configuration(), "/test", "aos.TestMessage", "",
+                                nullptr),
+      [](const Context &) {});
+}
+
 // Tests that fetcher work with a node setup.
 TEST_P(AbstractEventLoopTest, NodeFetcher) {
   EnableNodes("me");
@@ -1370,6 +1579,16 @@
             [](const Context &, const void *) {});
       },
       "node");
+  EXPECT_DEATH({ loop1->MakeNoArgWatcher<TestMessage>("/test", []() {}); },
+               "node");
+  EXPECT_DEATH(
+      {
+        loop2->MakeRawNoArgWatcher(
+            configuration::GetChannel(configuration(), "/test",
+                                      "aos.TestMessage", "", nullptr),
+            [](const Context &) {});
+      },
+      "node");
 }
 
 // Tests that fetchers fail when created on the wrong node.
diff --git a/aos/events/event_loop_tmpl.h b/aos/events/event_loop_tmpl.h
index 1daf88c..5534c83 100644
--- a/aos/events/event_loop_tmpl.h
+++ b/aos/events/event_loop_tmpl.h
@@ -6,13 +6,16 @@
 #include "glog/logging.h"
 
 namespace aos {
+namespace event_loop_internal {
 
-// From a watch functor, this will extract the message type of the argument.
-// This is the template forward declaration, and it extracts the call operator
-// as a PTMF to be used by the following specialization.
+// From a watch functor, specializations of this will extract the message type
+// of the template argument. If T is not a valid message type, there will be no
+// matching specialization.
+//
+// This is just the forward declaration, which will be used by one of the
+// following specializations to match valid argument types.
 template <class T>
-struct watch_message_type_trait
-    : watch_message_type_trait<decltype(&T::operator())> {};
+struct watch_message_type_trait;
 
 // From a watch functor, this will extract the message type of the argument.
 // This is the template specialization.
@@ -21,6 +24,8 @@
   using message_type = typename std::decay<A1>::type;
 };
 
+}  // namespace event_loop_internal
+
 template <typename T>
 typename Sender<T>::Builder Sender<T>::MakeBuilder() {
   return Builder(sender_.get(), sender_->fbb_allocator());
@@ -28,19 +33,38 @@
 
 template <typename Watch>
 void EventLoop::MakeWatcher(const std::string_view channel_name, Watch &&w) {
-  using T = typename watch_message_type_trait<Watch>::message_type;
+  using MessageType =
+      typename event_loop_internal::watch_message_type_trait<decltype(
+          &Watch::operator())>::message_type;
   const Channel *channel = configuration::GetChannel(
-      configuration_, channel_name, T::GetFullyQualifiedName(), name(), node());
+      configuration_, channel_name, MessageType::GetFullyQualifiedName(),
+      name(), node());
 
   CHECK(channel != nullptr)
       << ": Channel { \"name\": \"" << channel_name << "\", \"type\": \""
-      << T::GetFullyQualifiedName() << "\" } not found in config.";
+      << MessageType::GetFullyQualifiedName() << "\" } not found in config.";
 
-  return MakeRawWatcher(
-      channel, [this, w](const Context &context, const void *message) {
-        context_ = context;
-        w(*flatbuffers::GetRoot<T>(reinterpret_cast<const char *>(message)));
-      });
+  MakeRawWatcher(channel,
+                 [this, w](const Context &context, const void *message) {
+                   context_ = context;
+                   w(*flatbuffers::GetRoot<MessageType>(
+                       reinterpret_cast<const char *>(message)));
+                 });
+}
+
+template <typename MessageType>
+void EventLoop::MakeNoArgWatcher(const std::string_view channel_name,
+                                 std::function<void()> w) {
+  const Channel *channel = configuration::GetChannel(
+      configuration_, channel_name, MessageType::GetFullyQualifiedName(),
+      name(), node());
+  CHECK(channel != nullptr)
+      << ": Channel { \"name\": \"" << channel_name << "\", \"type\": \""
+      << MessageType::GetFullyQualifiedName() << "\" } not found in config.";
+  MakeRawNoArgWatcher(channel, [this, w](const Context &context) {
+    context_ = context;
+    w();
+  });
 }
 
 inline bool RawFetcher::FetchNext() {
@@ -194,7 +218,9 @@
   // context.
   void DoCallCallback(std::function<monotonic_clock::time_point()> get_time,
                       Context context) {
-    CheckChannelDataAlignment(context.data, context.size);
+    if (context.data) {
+      CheckChannelDataAlignment(context.data, context.size);
+    }
     const monotonic_clock::time_point monotonic_start_time = get_time();
     {
       const float start_latency =
diff --git a/aos/events/logging/log_stats.cc b/aos/events/logging/log_stats.cc
index 88bf15c..8243d9f 100644
--- a/aos/events/logging/log_stats.cc
+++ b/aos/events/logging/log_stats.cc
@@ -93,34 +93,39 @@
   int it = 0;  // iterate through the channel_stats
   for (flatbuffers::uoffset_t i = 0; i < channels->size(); i++) {
     const aos::Channel *channel = channels->Get(i);
-    if (channel->name()->string_view().find(FLAGS_name) != std::string::npos) {
-      // Add a record to the stats vector.
-      channel_stats.push_back({channel});
-      // Lambda to read messages and parse for information
-      stats_event_loop->MakeRawWatcher(
-          channel,
-          [&logfile_stats, &channel_stats, it](const aos::Context &context,
-                                               const void * /* message */) {
-            channel_stats[it].max_message_size =
-                std::max(channel_stats[it].max_message_size, context.size);
-            channel_stats[it].total_message_size += context.size;
-            channel_stats[it].total_num_messages++;
-            // asume messages are send in sequence per channel
-            channel_stats[it].channel_end_time = context.realtime_event_time;
-            channel_stats[it].first_message_time =
-                std::min(channel_stats[it].first_message_time,
-                         context.monotonic_event_time);
-            channel_stats[it].current_message_time =
-                context.monotonic_event_time;
-            // update the overall logfile statistics
-            logfile_stats.logfile_length += context.size;
-          });
-      it++;
-      // TODO (Stephan): Frequency of messages per second
-      // - Sliding window
-      // - Max / Deviation
-      found_channel = true;
+    if (!aos::configuration::ChannelIsReadableOnNode(
+            channel, stats_event_loop->node())) {
+      continue;
     }
+
+    if (channel->name()->string_view().find(FLAGS_name) == std::string::npos) {
+      continue;
+    }
+
+    // Add a record to the stats vector.
+    channel_stats.push_back({channel});
+    // Lambda to read messages and parse for information
+    stats_event_loop->MakeRawNoArgWatcher(
+        channel,
+        [&logfile_stats, &channel_stats, it](const aos::Context &context) {
+          channel_stats[it].max_message_size =
+              std::max(channel_stats[it].max_message_size, context.size);
+          channel_stats[it].total_message_size += context.size;
+          channel_stats[it].total_num_messages++;
+          // asume messages are send in sequence per channel
+          channel_stats[it].channel_end_time = context.realtime_event_time;
+          channel_stats[it].first_message_time =
+              std::min(channel_stats[it].first_message_time,
+                       context.monotonic_event_time);
+          channel_stats[it].current_message_time = context.monotonic_event_time;
+          // update the overall logfile statistics
+          logfile_stats.logfile_length += context.size;
+        });
+    it++;
+    // TODO (Stephan): Frequency of messages per second
+    // - Sliding window
+    // - Max / Deviation
+    found_channel = true;
   }
   if (!found_channel) {
     LOG(FATAL) << "Could not find any channels";
@@ -171,7 +176,7 @@
   }
   std::cout << std::setfill('-') << std::setw(80) << "-"
             << "\nLogfile statistics for: " << FLAGS_logfile << "\n"
-            << "Log starts at:\t" << reader.realtime_start_time() << "\n"
+            << "Log starts at:\t" << reader.realtime_start_time(node) << "\n"
             << "Log ends at:\t" << logfile_stats.logfile_end_time << "\n"
             << "Log file size:\t" << logfile_stats.logfile_length << "\n"
             << "Total messages:\t" << logfile_stats.total_log_messages << "\n";
diff --git a/aos/events/logging/logfile_utils.cc b/aos/events/logging/logfile_utils.cc
index f062ad3..a7238ba 100644
--- a/aos/events/logging/logfile_utils.cc
+++ b/aos/events/logging/logfile_utils.cc
@@ -8,6 +8,7 @@
 
 #include <vector>
 
+#include "absl/strings/escaping.h"
 #include "aos/configuration.h"
 #include "aos/events/logging/logger_generated.h"
 #include "aos/flatbuffer_merge.h"
@@ -181,6 +182,15 @@
   const size_t data_size =
       flatbuffers::GetPrefixedSize(data_.data() + consumed_data_) +
       sizeof(flatbuffers::uoffset_t);
+  if (data_size == sizeof(flatbuffers::uoffset_t)) {
+    LOG(ERROR) << "Size of data is zero.  Log file end is corrupted, skipping.";
+    LOG(ERROR) << "  Rest of log file is "
+               << absl::BytesToHexString(std::string_view(
+                      reinterpret_cast<const char *>(data_.data() +
+                                                     consumed_data_),
+                      data_.size() - consumed_data_));
+    return absl::Span<const uint8_t>();
+  }
   while (data_.size() < consumed_data_ + data_size) {
     if (!ReadBlock()) {
       return absl::Span<const uint8_t>();
diff --git a/aos/events/shm_event_loop.cc b/aos/events/shm_event_loop.cc
index 57bcb1c..afd65a3 100644
--- a/aos/events/shm_event_loop.cc
+++ b/aos/events/shm_event_loop.cc
@@ -81,16 +81,16 @@
     // already exist and we need to create it.  Start by trying to create it. If
     // that fails, the file has already been created and we can open it
     // normally..  Once the file has been created it wil never be deleted.
-    fd_ = open(path.c_str(), O_RDWR | O_CREAT | O_EXCL,
+    int fd = open(path.c_str(), O_RDWR | O_CREAT | O_EXCL,
                O_CLOEXEC | FLAGS_permissions);
-    if (fd_ == -1 && errno == EEXIST) {
+    if (fd == -1 && errno == EEXIST) {
       VLOG(1) << path << " already created.";
       // File already exists.
-      fd_ = open(path.c_str(), O_RDWR, O_CLOEXEC);
-      PCHECK(fd_ != -1) << ": Failed to open " << path;
+      fd = open(path.c_str(), O_RDWR, O_CLOEXEC);
+      PCHECK(fd != -1) << ": Failed to open " << path;
       while (true) {
         struct stat st;
-        PCHECK(fstat(fd_, &st) == 0);
+        PCHECK(fstat(fd, &st) == 0);
         if (st.st_size != 0) {
           CHECK_EQ(static_cast<size_t>(st.st_size), size_)
               << ": Size of " << path
@@ -105,19 +105,19 @@
       }
     } else {
       VLOG(1) << "Created " << path;
-      PCHECK(fd_ != -1) << ": Failed to open " << path;
-      PCHECK(ftruncate(fd_, size_) == 0);
+      PCHECK(fd != -1) << ": Failed to open " << path;
+      PCHECK(ftruncate(fd, size_) == 0);
     }
 
-    data_ = mmap(NULL, size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0);
+    data_ = mmap(NULL, size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     PCHECK(data_ != MAP_FAILED);
+    PCHECK(close(fd) == 0);
 
     ipc_lib::InitializeLocklessQueueMemory(memory(), config_);
   }
 
   ~MMapedQueue() {
     PCHECK(munmap(data_, size_) == 0);
-    PCHECK(close(fd_) == 0);
   }
 
   ipc_lib::LocklessQueueMemory *memory() const {
@@ -133,8 +133,6 @@
  private:
   ipc_lib::LocklessQueueConfiguration config_;
 
-  int fd_;
-
   size_t size_;
   void *data_;
 };
@@ -166,17 +164,19 @@
 
 class SimpleShmFetcher {
  public:
-  explicit SimpleShmFetcher(EventLoop *event_loop, const Channel *channel)
+  explicit SimpleShmFetcher(EventLoop *event_loop, const Channel *channel,
+                            bool copy_data)
       : channel_(channel),
         lockless_queue_memory_(
             channel,
             chrono::ceil<chrono::seconds>(chrono::nanoseconds(
                 event_loop->configuration()->channel_storage_duration()))),
         lockless_queue_(lockless_queue_memory_.memory(),
-                        lockless_queue_memory_.config()),
-        data_storage_(static_cast<char *>(malloc(channel->max_size() +
-                                                 kChannelDataAlignment - 1)),
-                      &free) {
+                        lockless_queue_memory_.config()) {
+    if (copy_data) {
+      data_storage_.reset(static_cast<char *>(
+          malloc(channel->max_size() + kChannelDataAlignment - 1)));
+    }
     context_.data = nullptr;
     // Point the queue index at the next index to read starting now.  This
     // makes it such that FetchNext will read the next message sent after
@@ -219,8 +219,12 @@
       if (context_.realtime_remote_time == aos::realtime_clock::min_time) {
         context_.realtime_remote_time = context_.realtime_event_time;
       }
-      context_.data = data_storage_start() +
-                      lockless_queue_.message_data_size() - context_.size;
+      if (copy_data()) {
+        context_.data = data_storage_start() +
+                        lockless_queue_.message_data_size() - context_.size;
+      } else {
+        context_.data = nullptr;
+      }
       actual_queue_index_ = actual_queue_index_.Increment();
     }
 
@@ -269,8 +273,12 @@
       if (context_.realtime_remote_time == aos::realtime_clock::min_time) {
         context_.realtime_remote_time = context_.realtime_event_time;
       }
-      context_.data = data_storage_start() +
-                      lockless_queue_.message_data_size() - context_.size;
+      if (copy_data()) {
+        context_.data = data_storage_start() +
+                        lockless_queue_.message_data_size() - context_.size;
+      } else {
+        context_.data = nullptr;
+      }
       actual_queue_index_ = queue_index.Increment();
     }
 
@@ -310,8 +318,10 @@
 
  private:
   char *data_storage_start() {
+    if (!copy_data()) return nullptr;
     return RoundChannelData(data_storage_.get(), channel_->max_size());
   }
+  bool copy_data() const { return static_cast<bool>(data_storage_); }
 
   const Channel *const channel_;
   MMapedQueue lockless_queue_memory_;
@@ -320,7 +330,8 @@
   ipc_lib::QueueIndex actual_queue_index_ =
       ipc_lib::LocklessQueue::empty_queue_index();
 
-  std::unique_ptr<char, decltype(&free)> data_storage_;
+  // This being empty indicates we're not going to copy data.
+  std::unique_ptr<char, decltype(&free)> data_storage_{nullptr, &free};
 
   Context context_;
 };
@@ -329,7 +340,7 @@
  public:
   explicit ShmFetcher(EventLoop *event_loop, const Channel *channel)
       : RawFetcher(event_loop, channel),
-        simple_shm_fetcher_(event_loop, channel) {}
+        simple_shm_fetcher_(event_loop, channel, true) {}
 
   ~ShmFetcher() { context_.data = nullptr; }
 
@@ -408,11 +419,12 @@
  public:
   WatcherState(
       ShmEventLoop *event_loop, const Channel *channel,
-      std::function<void(const Context &context, const void *message)> fn)
+      std::function<void(const Context &context, const void *message)> fn,
+      bool copy_data)
       : aos::WatcherState(event_loop, channel, std::move(fn)),
         event_loop_(event_loop),
         event_(this),
-        simple_shm_fetcher_(event_loop, channel) {}
+        simple_shm_fetcher_(event_loop, channel, copy_data) {}
 
   ~WatcherState() override { event_loop_->RemoveEvent(&event_); }
 
@@ -617,7 +629,18 @@
   TakeWatcher(channel);
 
   NewWatcher(::std::unique_ptr<WatcherState>(
-      new internal::WatcherState(this, channel, std::move(watcher))));
+      new internal::WatcherState(this, channel, std::move(watcher), true)));
+}
+
+void ShmEventLoop::MakeRawNoArgWatcher(
+    const Channel *channel,
+    std::function<void(const Context &context)> watcher) {
+  TakeWatcher(channel);
+
+  NewWatcher(::std::unique_ptr<WatcherState>(new internal::WatcherState(
+      this, channel,
+      [watcher](const Context &context, const void *) { watcher(context); },
+      false)));
 }
 
 TimerHandler *ShmEventLoop::AddTimer(::std::function<void()> callback) {
diff --git a/aos/events/shm_event_loop.h b/aos/events/shm_event_loop.h
index fa870b8..d3f1295 100644
--- a/aos/events/shm_event_loop.h
+++ b/aos/events/shm_event_loop.h
@@ -52,6 +52,9 @@
       const Channel *channel,
       std::function<void(const Context &context, const void *message)> watcher)
       override;
+  void MakeRawNoArgWatcher(
+      const Channel *channel,
+      std::function<void(const Context &context)> watcher) override;
 
   TimerHandler *AddTimer(std::function<void()> callback) override;
   aos::PhasedLoopHandler *AddPhasedLoop(
diff --git a/aos/events/simulated_network_bridge.cc b/aos/events/simulated_network_bridge.cc
index 1f56e46..0ab366a 100644
--- a/aos/events/simulated_network_bridge.cc
+++ b/aos/events/simulated_network_bridge.cc
@@ -174,9 +174,8 @@
     }
 
     // And register every delayer to be poked when a new message shows up.
-    source_event_loop->second->MakeRawWatcher(
-        channel,
-        [captured_delayers = delayers.get()](const Context &, const void *) {
+    source_event_loop->second->MakeRawNoArgWatcher(
+        channel, [captured_delayers = delayers.get()](const Context &) {
           for (std::unique_ptr<RawMessageDelayer> &delayer :
                *captured_delayers) {
             delayer->Schedule();
diff --git a/aos/init.cc b/aos/init.cc
index 5d62868..c40f22c 100644
--- a/aos/init.cc
+++ b/aos/init.cc
@@ -24,6 +24,8 @@
 using FLAG__namespace_do_not_use_directly_use_DECLARE_double_instead::
     FLAGS_tcmalloc_release_rate;
 
+DEFINE_bool(coredump, false, "If true, write core dumps on failure.");
+
 namespace aos {
 namespace logging {
 namespace internal {
@@ -39,7 +41,9 @@
 // non-realtime initialization sequences. May be called twice.
 void InitStart() {
   ::aos::logging::Init();
-  WriteCoreDumps();
+  if (FLAGS_coredump) {
+    WriteCoreDumps();
+  }
   google::InstallFailureSignalHandler();
 }
 
diff --git a/aos/ipc_lib/lockless_queue.cc b/aos/ipc_lib/lockless_queue.cc
index 7126ffd..f31d80d 100644
--- a/aos/ipc_lib/lockless_queue.cc
+++ b/aos/ipc_lib/lockless_queue.cc
@@ -792,7 +792,9 @@
   }
   *monotonic_remote_time = m->header.monotonic_remote_time;
   *realtime_remote_time = m->header.realtime_remote_time;
-  memcpy(data, m->data(memory_->message_data_size()), message_data_size());
+  if (data) {
+    memcpy(data, m->data(memory_->message_data_size()), message_data_size());
+  }
   *length = m->header.length;
 
   // And finally, confirm that the message *still* points to the queue index we
diff --git a/aos/ipc_lib/lockless_queue.h b/aos/ipc_lib/lockless_queue.h
index 0384aa8..550485f 100644
--- a/aos/ipc_lib/lockless_queue.h
+++ b/aos/ipc_lib/lockless_queue.h
@@ -162,6 +162,8 @@
   // element newer than QueueSize() from the current message, we consider it
   // behind by a large amount and return TOO_OLD.  If the message is modified
   // out from underneath us as we read it, return OVERWROTE.
+  //
+  // data may be nullptr to indicate the data should not be copied.
   enum class ReadResult { TOO_OLD, GOOD, NOTHING_NEW, OVERWROTE };
   ReadResult Read(uint32_t queue_index,
                   ::aos::monotonic_clock::time_point *monotonic_sent_time,
diff --git a/aos/network/sctp_server.cc b/aos/network/sctp_server.cc
index 5fd9f53..093e3f0 100644
--- a/aos/network/sctp_server.cc
+++ b/aos/network/sctp_server.cc
@@ -10,6 +10,7 @@
 #include <string.h>
 #include <sys/socket.h>
 #include <memory>
+#include <thread>
 
 #include "aos/network/sctp_lib.h"
 #include "aos/unique_malloc_ptr.h"
@@ -19,51 +20,60 @@
 namespace message_bridge {
 
 SctpServer::SctpServer(std::string_view local_host, int local_port)
-    : sockaddr_local_(ResolveSocket(local_host, local_port)),
-      fd_(socket(sockaddr_local_.ss_family, SOCK_SEQPACKET, IPPROTO_SCTP)) {
-  LOG(INFO) << "socket(" << Family(sockaddr_local_)
-            << ", SOCK_SEQPACKET, IPPROTOSCTP) = " << fd_;
-  PCHECK(fd_ != -1);
+    : sockaddr_local_(ResolveSocket(local_host, local_port)) {
+  while (true) {
+    fd_ = socket(sockaddr_local_.ss_family, SOCK_SEQPACKET, IPPROTO_SCTP);
+    LOG(INFO) << "socket(" << Family(sockaddr_local_)
+              << ", SOCK_SEQPACKET, IPPROTOSCTP) = " << fd_;
+    PCHECK(fd_ != -1);
 
-  {
-    struct sctp_event_subscribe subscribe;
-    memset(&subscribe, 0, sizeof(subscribe));
-    subscribe.sctp_data_io_event = 1;
-    subscribe.sctp_association_event = 1;
-    subscribe.sctp_send_failure_event = 1;
-    subscribe.sctp_partial_delivery_event = 1;
+    {
+      struct sctp_event_subscribe subscribe;
+      memset(&subscribe, 0, sizeof(subscribe));
+      subscribe.sctp_data_io_event = 1;
+      subscribe.sctp_association_event = 1;
+      subscribe.sctp_send_failure_event = 1;
+      subscribe.sctp_partial_delivery_event = 1;
 
-    PCHECK(setsockopt(fd_, SOL_SCTP, SCTP_EVENTS, (char *)&subscribe,
-                      sizeof(subscribe)) == 0);
+      PCHECK(setsockopt(fd_, SOL_SCTP, SCTP_EVENTS, (char *)&subscribe,
+                        sizeof(subscribe)) == 0);
+    }
+    {
+      // Enable recvinfo when a packet arrives.
+      int on = 1;
+      PCHECK(setsockopt(fd_, IPPROTO_SCTP, SCTP_RECVRCVINFO, &on,
+                        sizeof(int)) == 0);
+    }
+    {
+      // Allow one packet on the wire to have multiple source packets.
+      int full_interleaving = 2;
+      PCHECK(setsockopt(fd_, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE,
+                        &full_interleaving, sizeof(full_interleaving)) == 0);
+    }
+    {
+      // Turn off the NAGLE algorithm.
+      int on = 1;
+      PCHECK(setsockopt(fd_, IPPROTO_SCTP, SCTP_NODELAY, &on, sizeof(int)) ==
+             0);
+    }
+
+    // And go!
+    if (bind(fd_, (struct sockaddr *)&sockaddr_local_,
+             sockaddr_local_.ss_family == AF_INET6
+                 ? sizeof(struct sockaddr_in6)
+                 : sizeof(struct sockaddr_in)) != 0) {
+      PLOG(ERROR) << "Failed to bind, retrying";
+      close(fd_);
+      std::this_thread::sleep_for(std::chrono::seconds(5));
+      continue;
+    }
+    LOG(INFO) << "bind(" << fd_ << ", " << Address(sockaddr_local_) << ")";
+
+    PCHECK(listen(fd_, 100) == 0);
+
+    SetMaxSize(1000);
+    break;
   }
-  {
-    // Enable recvinfo when a packet arrives.
-    int on = 1;
-    PCHECK(setsockopt(fd_, IPPROTO_SCTP, SCTP_RECVRCVINFO, &on, sizeof(int)) ==
-           0);
-  }
-  {
-    // Allow one packet on the wire to have multiple source packets.
-    int full_interleaving = 2;
-    PCHECK(setsockopt(fd_, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE,
-                      &full_interleaving, sizeof(full_interleaving)) == 0);
-  }
-  {
-    // Turn off the NAGLE algorithm.
-    int on = 1;
-    PCHECK(setsockopt(fd_, IPPROTO_SCTP, SCTP_NODELAY, &on, sizeof(int)) == 0);
-  }
-
-  // And go!
-  PCHECK(bind(fd_, (struct sockaddr *)&sockaddr_local_,
-              sockaddr_local_.ss_family == AF_INET6
-                  ? sizeof(struct sockaddr_in6)
-                  : sizeof(struct sockaddr_in)) == 0);
-  LOG(INFO) << "bind(" << fd_ << ", " << Address(sockaddr_local_) << ")";
-
-  PCHECK(listen(fd_, 100) == 0);
-
-  SetMaxSize(1000);
 }
 
 aos::unique_c_ptr<Message> SctpServer::Read() {
diff --git a/debian/BUILD b/debian/BUILD
index 7f3b7f1..dee25cb 100644
--- a/debian/BUILD
+++ b/debian/BUILD
@@ -56,6 +56,14 @@
     ":opencv_amd64.bzl",
     opencv_amd64_debs = "files",
 )
+load(
+    ":gstreamer_amd64.bzl",
+    gstreamer_amd64_debs = "files",
+)
+load(
+    ":gstreamer_armhf.bzl",
+    gstreamer_armhf_debs = "files",
+)
 load("//debian:packages.bzl", "download_packages", "generate_deb_tarball")
 
 filegroup(
@@ -306,6 +314,16 @@
     files = opencv_amd64_debs,
 )
 
+generate_deb_tarball(
+    name = "gstreamer_amd64",
+    files = gstreamer_amd64_debs,
+)
+
+generate_deb_tarball(
+    name = "gstreamer_armhf",
+    files = gstreamer_armhf_debs,
+)
+
 exports_files([
     "ssh_wrapper.sh",
 ])
diff --git a/debian/download_packages.py b/debian/download_packages.py
index 5ad46e1..6331102 100755
--- a/debian/download_packages.py
+++ b/debian/download_packages.py
@@ -29,6 +29,30 @@
     if package == b'python3-numpy-abi9':
       yield b'python3-numpy'
       continue
+    if package == b'libjack-0.125':
+      yield b'libjack-jackd2-0'
+      continue
+    if package == b'fonts-freefont':
+      yield b'fonts-freefont-ttf'
+      continue
+    if package == b'gsettings-backend':
+      yield b'dconf-gsettings-backend'
+      continue
+    if package == b'gdal-abi-2-4-0':
+      yield b'libgdal20'
+      continue
+    if package == b'libglu1':
+      yield b'libglu1-mesa'
+      continue
+    if package == b'liblapack.so.3':
+      yield b'liblapack3'
+      continue
+    if package == b'libopencl1':
+      yield b'ocl-icd-libopencl1'
+      continue
+    if package == b'libblas.so.3':
+      yield b'libblas3'
+      continue
     yield package
 
 def download_deps(packages, excludes, force_includes):
@@ -65,8 +89,10 @@
   print("}")
 
 _ALWAYS_EXCLUDE = [
+    "dbus-session-bus",
     "debconf",
     "debconf-2.0",
+    "default-dbus-session-bus",
     "dpkg",
     "install-info",
     "libc-dev",
diff --git a/debian/gstreamer.BUILD b/debian/gstreamer.BUILD
new file mode 100644
index 0000000..a3d1b82
--- /dev/null
+++ b/debian/gstreamer.BUILD
@@ -0,0 +1,191 @@
+load("@//tools/build_rules:select.bzl", "cpu_select")
+
+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",
+        ],
+        "roborio": [
+        ],
+        "armhf": [
+            "lib/arm-linux-gnueabihf/libblkid.so.1",
+            "lib/arm-linux-gnueabihf/libcom_err.so.2",
+            "lib/arm-linux-gnueabihf/libexpat.so.1",
+            "lib/arm-linux-gnueabihf/libkeyutils.so.1",
+            "lib/arm-linux-gnueabihf/liblzma.so.5",
+            "lib/arm-linux-gnueabihf/libmount.so.1",
+            "lib/arm-linux-gnueabihf/libpcre.so.3",
+            "lib/arm-linux-gnueabihf/libselinux.so.1",
+            "lib/arm-linux-gnueabihf/libudev.so.1",
+            "lib/arm-linux-gnueabihf/libuuid.so.1",
+            "lib/arm-linux-gnueabihf/libz.so.1",
+            "usr/lib/arm-linux-gnueabihf/libEGL.so.1",
+            "usr/lib/arm-linux-gnueabihf/libGL.so.1",
+            "usr/lib/arm-linux-gnueabihf/libGLX.so.0",
+            "usr/lib/arm-linux-gnueabihf/libGLdispatch.so.0",
+            "usr/lib/arm-linux-gnueabihf/libX11-xcb.so.1",
+            "usr/lib/arm-linux-gnueabihf/libX11.so.6",
+            "usr/lib/arm-linux-gnueabihf/libXau.so.6",
+            "usr/lib/arm-linux-gnueabihf/libXdmcp.so.6",
+            "usr/lib/arm-linux-gnueabihf/libatomic.so.1",
+            "usr/lib/arm-linux-gnueabihf/libbsd.so.0",
+            "usr/lib/arm-linux-gnueabihf/libdrm.so.2",
+            "usr/lib/arm-linux-gnueabihf/libffi.so.6",
+            "usr/lib/arm-linux-gnueabihf/libgbm.so.1",
+            "usr/lib/arm-linux-gnueabihf/libgio-2.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libglib-2.0.so",
+            "usr/lib/arm-linux-gnueabihf/libgmodule-2.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgmp.so.10",
+            "usr/lib/arm-linux-gnueabihf/libgnutls.so.30",
+            "usr/lib/arm-linux-gnueabihf/libgobject-2.0.so",
+            "usr/lib/arm-linux-gnueabihf/libgssapi_krb5.so.2",
+            "usr/lib/arm-linux-gnueabihf/libgssdp-1.0.so.3",
+            "usr/lib/arm-linux-gnueabihf/libgstallocators-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstapp-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstaudio-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstbadvideo-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstbase-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstgl-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstreamer-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstrtp-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstsdp-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgsttag-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstvideo-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgstwebrtc-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgthread-2.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgudev-1.0.so.0",
+            "usr/lib/arm-linux-gnueabihf/libgupnp-1.0.so.4",
+            "usr/lib/arm-linux-gnueabihf/libgupnp-igd-1.0.so.4",
+            "usr/lib/arm-linux-gnueabihf/libhogweed.so.4",
+            "usr/lib/arm-linux-gnueabihf/libicudata.so.63",
+            "usr/lib/arm-linux-gnueabihf/libicui18n.so.63",
+            "usr/lib/arm-linux-gnueabihf/libicuuc.so.63",
+            "usr/lib/arm-linux-gnueabihf/libidn2.so.0",
+            "usr/lib/arm-linux-gnueabihf/libjpeg.so.62",
+            "usr/lib/arm-linux-gnueabihf/libk5crypto.so.3",
+            "usr/lib/arm-linux-gnueabihf/libkrb5.so.3",
+            "usr/lib/arm-linux-gnueabihf/libkrb5support.so.0",
+            "usr/lib/arm-linux-gnueabihf/libnettle.so.6",
+            "usr/lib/arm-linux-gnueabihf/libnice.so.10",
+            "usr/lib/arm-linux-gnueabihf/libopencv_core.so.3.2",
+            "usr/lib/arm-linux-gnueabihf/liborc-0.4.so.0",
+            "usr/lib/arm-linux-gnueabihf/libp11-kit.so.0",
+            "usr/lib/arm-linux-gnueabihf/libpsl.so.5",
+            "usr/lib/arm-linux-gnueabihf/libsoup-2.4.so.1",
+            "usr/lib/arm-linux-gnueabihf/libsqlite3.so.0",
+            "usr/lib/arm-linux-gnueabihf/libtasn1.so.6",
+            "usr/lib/arm-linux-gnueabihf/libtbb.so.2",
+            "usr/lib/arm-linux-gnueabihf/libunistring.so.2",
+            "usr/lib/arm-linux-gnueabihf/libvpx.so.5",
+            "usr/lib/arm-linux-gnueabihf/libwayland-client.so.0",
+            "usr/lib/arm-linux-gnueabihf/libwayland-egl.so.1",
+            "usr/lib/arm-linux-gnueabihf/libwayland-server.so.0",
+            "usr/lib/arm-linux-gnueabihf/libx265.so.165",
+            "usr/lib/arm-linux-gnueabihf/libxcb.so.1",
+            "usr/lib/arm-linux-gnueabihf/libxml2.so.2",
+        ],
+        "cortex-m": [],
+    }),
+    hdrs = glob([
+        "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",
+    ]),
+    includes = cpu_select({
+        "amd64": [
+            "usr/lib/x86_64-linux-gnu/glib-2.0/include",
+            "usr/include/glib-2.0",
+            "usr/include/gstreamer-1.0",
+        ],
+        "armhf": [
+            "usr/lib/arm-linux-gnueabihf/glib-2.0/include",
+            "usr/include/glib-2.0",
+            "usr/include/gstreamer-1.0",
+        ],
+        "roborio": [
+        ],
+        "cortex-m": [
+        ],
+    }),
+    linkopts = [
+        "-ldl",
+        "-lresolv",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/debian/gstreamer_amd64.bzl b/debian/gstreamer_amd64.bzl
new file mode 100644
index 0000000..65c03af
--- /dev/null
+++ b/debian/gstreamer_amd64.bzl
@@ -0,0 +1,511 @@
+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",
+    "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",
+    "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",
+    "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",
+    "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": "c1d8c2c8943f95511811eea4c85ee72cec9cf1442d16db18e135e589a77dc050",
+    "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",
+    "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",
+    "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",
+    "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",
+    "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",
+    "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",
+    "libxft2_2.3.2-2_amd64.deb": "cd71384b4d511cba69bcee29af326943c7ca12450765f44c40d246608c779aad",
+    "libxi6_1.7.9-1_amd64.deb": "fe26733adf2025f184bf904caf088a5d3f6aa29a8863b616af9cafaad85b1237",
+    "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",
+    "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",
+    "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",
+}
diff --git a/debian/gstreamer_armhf.bzl b/debian/gstreamer_armhf.bzl
new file mode 100644
index 0000000..d204ccb
--- /dev/null
+++ b/debian/gstreamer_armhf.bzl
@@ -0,0 +1,483 @@
+files = {
+    "adduser_3.118_all.deb": "bd71dd1ab8dcd6005390708f23741d07f1913877affb7604dfd55f85d009aa2b",
+    "adwaita-icon-theme_3.30.1-1_all.deb": "698b3f0fa337bb36ea4fe072a37a32a1c81875db13042368677490bb087ccb93",
+    "coreutils_8.30-3_armhf.deb": "6a578920fe016ce628065f4c7a2639a6ffc3d52637e4b4f20a46ea76fcc05539",
+    "dconf-gsettings-backend_0.30.1-2_armhf.deb": "61bd02ba2da9e549e245ab2f5152baa2f27ea40fd0b0cde5873c63048feaa708",
+    "dconf-service_0.30.1-2_armhf.deb": "2ddc0eddff21e18afda15379d6414ffea5ea21a10e958c2ddc85625feab5cf70",
+    "fontconfig-config_2.13.1-2_all.deb": "9f5d34ba20eb156ef62d8126866a376be985c6a83fdcfb33f12cd83acac480c2",
+    "fontconfig_2.13.1-2_armhf.deb": "f2d17a9588f37d149e2777bdeb6acbc8bad203b814c8983b34ddee24ce316421",
+    "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_armhf.deb": "9db56815153e9db7a235454a6a49bc5080227d285b13645cd0a7479e6531d599",
+    "gir1.2-gst-plugins-bad-1.0_1.14.4-1+b1_armhf.deb": "a8c9a005c1e91a7ceeeb15e0bc2a6f42a3b032e3d616301a2544065c39e0aa7b",
+    "gir1.2-gst-plugins-base-1.0_1.14.4-2_armhf.deb": "f03297871471f50628d89634fd19cf80d87f8e0f42ae221ce40ec9bdb3bfb901",
+    "gir1.2-gstreamer-1.0_1.14.4-1_armhf.deb": "4509ccdb92fcddd98ffe5807eb46553ea3c0324dcfca6987a37f32f786f8b815",
+    "glib-networking-common_2.58.0-2_all.deb": "79831fd09fc96dc5729e8ed360563b05100d6bff70b03f3badf4e0f4759bb7ec",
+    "glib-networking-services_2.58.0-2_armhf.deb": "f901428286b7d10acac92159d6e0b9c3e09691dbe7d5ec4848f962491f0805d6",
+    "glib-networking_2.58.0-2_armhf.deb": "713ec6741147cc75468f8c16cda12185aa5b11ec79cfcc5786790febf1664aaf",
+    "gsettings-desktop-schemas_3.28.1-1_all.deb": "a75aed8781a781c4b819b2d1e952791b123580b1a02a4bb35fdbbba2e3ab8310",
+    "gstreamer1.0-plugins-bad_1.14.4-1+b1_armhf.deb": "8e19a98c55d43b1524b1a8ce7658e396e1010f1581608a9fb9267e145848b484",
+    "gstreamer1.0-plugins-base_1.14.4-2_armhf.deb": "bbcad1ee299ce211edcbc6b16a1b4e5c2f046c74d6f3f733b9ba1df1e61c1a86",
+    "gstreamer1.0-plugins-good_1.14.4-1+rpt1_armhf.deb": "f091ec762f6ac05bd76b20300b4e242fe64fa71e41244fdc92f85f6b95900cf9",
+    "gstreamer1.0-plugins-ugly_1.14.4-1_armhf.deb": "3b3479c2fcde1c0e6b7931ff463181b59a9347d6a2f53111655a9e49a9696ee8",
+    "gtk-update-icon-cache_3.24.5-1+rpt2_armhf.deb": "8ed36c27190370354987249416dd4d19545a9e82e6020f271499bf72db067e8b",
+    "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_armhf.deb": "b0a3b3277e6a8b8a3644f451675f17b16c29daf7c4f78c90aa93bb60f3d4fb73",
+    "libaa1_1.4p5-46_armhf.deb": "d8f2bfb7889d8bafa002047dd7bf5eef0893b8c826974411f3f5a7e1c0f37ba6",
+    "libaec0_1.0.2-1_armhf.deb": "6a8107a0253577259ccadd5c274664bf7cb7f0d6e67a694d7ff0da7af850a7e9",
+    "libaom0_1.0.0-3_armhf.deb": "eca4cfebdc6f8afcdf141e17097c37c4094da61bb220c5c6fdf7faf2ef9badd6",
+    "libarmadillo9_9.200.7+dfsg-1_armhf.deb": "30e835a8de5c42bcede50b98f10ac2292d2677de12fbb44349b4611cc8803ad8",
+    "libarpack2_3.7.0-2_armhf.deb": "a1a466a360902651a8722539a39521787afe10df067a47b8d6b070e3cdc35b60",
+    "libatk-bridge2.0-0_2.30.0-5_armhf.deb": "7c7900d671e6a04cada9f36162a7a2e411763b19b08a2cd6b81ec9c249d24445",
+    "libatk1.0-0_2.30.0-2_armhf.deb": "c2c32c8784a995894da3b76d9c5e9269f64cb2cf3c28971a1cbede53190605c2",
+    "libatk1.0-data_2.30.0-2_all.deb": "cf0c94611ff2245ae31d12a5a43971eb4ca628f42e93b0e003fd2c4c0de5e533",
+    "libatomic1_8.3.0-6+rpi1_armhf.deb": "f0c29af98f8358dc7d38a25f12a1f82ee8f876336ca459c25c08f42754b03865",
+    "libatspi2.0-0_2.30.0-7_armhf.deb": "05980a3e666d895433b8bd24306d67d2362ead58199253ce2e699f9dc4e8fa5d",
+    "libaudit-common_2.8.4-3_all.deb": "4e51dc247cde083528d410f525c6157b08be8b69511891cf972bc87025311371",
+    "libaudit1_2.8.4-3_armhf.deb": "25378f4115b0c71b352ea91095e85d5ddced7ceb7b46448abb8cb53a0bc02da9",
+    "libavahi-client3_0.7-4+b1_armhf.deb": "8555f041940308d4bb24558d8eed6c506287d95ea151814c9fb5572ef68b9797",
+    "libavahi-common-data_0.7-4+b1_armhf.deb": "064992922f2ff006f0dea327fb5c38e1328fe58e17eb55a6c2ceac4dc531c46d",
+    "libavahi-common3_0.7-4+b1_armhf.deb": "6d40047dc95d3d24c75763288367eb651cac1e93ad167d9c4cae6eb6ffc7fa59",
+    "libavc1394-0_0.5.4-5_armhf.deb": "aa01717d78dd53f1a99f465df74ae2610b3703e7750336145e1e3e04baf883f9",
+    "libavcodec-dev_4.1.4-1+rpt7~deb10u1_armhf.deb": "fe6ee3da336a5a8f5365362b9aa7728eaa0b36bfc34a8104e1e0df8f4344f7d8",
+    "libavcodec58_4.1.4-1+rpt7~deb10u1_armhf.deb": "b2184abb8435e836de2ff024d3d61b0c8320761a15c38aff40de3221bacd0bb6",
+    "libavformat-dev_4.1.4-1+rpt7~deb10u1_armhf.deb": "0c421d613cbe64e7ed87f1c578419ef616bb3dc7b325d7e3dee807755c637200",
+    "libavformat58_4.1.4-1+rpt7~deb10u1_armhf.deb": "06684df7e331441a4babd7e6277d3812e505aaef880beef934c18c28261767e5",
+    "libavresample-dev_4.1.4-1+rpt7~deb10u1_armhf.deb": "03cb25f0b809a5b3c68b900ca7ec283e0b128ddfb11242ab3e6f2491d971fed2",
+    "libavresample4_4.1.4-1+rpt7~deb10u1_armhf.deb": "dd21854cf27f3c4272dc7557692ccd3977e226abc06a0c39a42f1ac1080badae",
+    "libavutil-dev_4.1.4-1+rpt7~deb10u1_armhf.deb": "6f1420ce4d3be31857eb6b280839c0e5e83d57eed643db09f87a376f3f283668",
+    "libavutil56_4.1.4-1+rpt7~deb10u1_armhf.deb": "812597883472bcf6d08be76d64cf21a94ae457a53e8d80e4978a6b6d385ac78f",
+    "libblas3_3.8.0-2_armhf.deb": "4231b6d249eb60cb13e9fc65e4378bc9e7908407a3b49a6fcdd4e88eb5df9f3d",
+    "libblkid-dev_2.33.1-0.1_armhf.deb": "1274ba8a74c2144ddd3d6124cc81d1bffad228af6a5553e7e85dc72d515bc46f",
+    "libblkid1_2.33.1-0.1_armhf.deb": "92801e35c3dbe24f2cb45d76e0837bc3928ecf2c1016ab07e827097634afa2c0",
+    "libbluray2_1.1.0-1_armhf.deb": "670a11be9d786fa07e472928893f78ba57140cd7caecfb1e396802d3ef8863dd",
+    "libbsd0_0.9.1-2_armhf.deb": "49164a38e2aa95b45e154dafa9974765554bad662c6ee865244a1b115d568b94",
+    "libcaca0_0.99.beta19-2.1_armhf.deb": "64ceea26af598559ad86340934cdeec15e24a9bf41c7612d485c72efb6649b73",
+    "libcairo-gobject2_1.16.0-4+rpt1_armhf.deb": "e3fdc6667bb647e0804cbad1eb369949d7caa8a711592786b158d0bc62c576cf",
+    "libcairo2_1.16.0-4+rpt1_armhf.deb": "1f651a306f87337b4b493ba248a09813a6da8acf60bea8ad3669a06d9d522c9f",
+    "libcap-ng0_0.7.9-2_armhf.deb": "5218a1d5d264620e027391df53c66ddc3cb5715e0aa6065238118fa3515b5e7b",
+    "libcap2-bin_2.25-2_armhf.deb": "6df8f6dcb1bf24ede50229db5c608f25be4062dddf05236325ca4294daecda6d",
+    "libcap2_2.25-2_armhf.deb": "7551421c6d90142f9d50a107d3788ee049a1bd2d0352b625878689d26d5a21a1",
+    "libcdio18_2.0.0-2_armhf.deb": "baaf8dd1247da5b90ff5c784e4b3cdb5374f7e4b7ff3ab643af78c91435da081",
+    "libcdparanoia0_3.10.2+debian-13_armhf.deb": "649c4fd73c996d730e95eb5712897dc61aaf1d6358459e5b9c20063c4ce1556a",
+    "libcharls2_2.0.0+dfsg-1_armhf.deb": "fa95753cbe407167cf4959f9ac02ac5db804fbaad1aaf5e04fc0bc2839502ee4",
+    "libchromaprint1_1.4.3-3_armhf.deb": "ae8106e0e758a423a89443fd1abb180d5ba3e6b208c93fc4f4a619390331abd1",
+    "libcodec2-0.8.1_0.8.1-2_armhf.deb": "21b065c1587dfa8ca1d8b9cbf0c797c56fa19738b2f697886091305cbdd891e6",
+    "libcolord2_1.4.3-4_armhf.deb": "4eec3912d5e1df92ef8d71a9c72aad2d7cc31c05edde8b583f3ee94c0181fe25",
+    "libcom-err2_1.44.5-1+deb10u3_armhf.deb": "9681e00461b693393d7dcc5d095aa4856a0325ed8c1757f138369b2158ccddd1",
+    "libcroco3_0.6.12-3_armhf.deb": "45940fc83e016ab6921a17001125b4fd0743ff37a87d2cf503c97a9b73e50f3b",
+    "libcups2_2.2.10-6+deb10u2_armhf.deb": "c7410b0a8b08e0b5a32c6b1cb5f29dd7b87fd6f8caeb87a358fce68f3b94f094",
+    "libcurl3-gnutls_7.64.0-4_armhf.deb": "1f52639539ccc0b358c4bac4d4044fe95db30acbaa2d27765c7132632a11047e",
+    "libdap25_3.20.3-1_armhf.deb": "e4a7a8502e233d355eadbcfad793d23a6e2b5dfbfda813aef3b76e91da6178f6",
+    "libdapclient6v5_3.20.3-1_armhf.deb": "beee7cb7642fcfd2d550908ae019a833195eb46ae5e5fac3732ab8208e0626a9",
+    "libdapserver7v5_3.20.3-1_armhf.deb": "cb4b57096e13161c5368db9d2ae868ba377a177a17dbb47503bfc1d022019b6e",
+    "libdatrie1_0.2.12-2_armhf.deb": "8e57fcfce1f6cad89e48332931d3ac3e7d65838ef36108dcb8cb9b8689268704",
+    "libdb5.3_5.3.28+dfsg1-0.5_armhf.deb": "e9bfd3904dfbdab095f24f4e3d2736c1cabd0fc0a13c06239fc795dc3fd394fa",
+    "libdbus-1-3_1.12.16-1_armhf.deb": "8956d26ed5e36da1827b295af1db20c4c3326c2fb6286df0611af1fddadfe148",
+    "libdc1394-22-dev_2.2.5-1_armhf.deb": "e1181d30983e2388f30168a06e347af77f63dadd472d7f10a06c0453c9854492",
+    "libdc1394-22_2.2.5-1_armhf.deb": "dc9d04ccaaf4c9d8e789a81b5eee65f3b7dbc16dedd492106d5494a14cc024f6",
+    "libdconf1_0.30.1-2_armhf.deb": "6ede031759943492bbc180e8d370b68d22279158a73ed692501b0e2347491cde",
+    "libdpkg-perl_1.19.7_all.deb": "1cb272a8168138e9b8334e87cc26388259f232b74667b3a7f3856f227adcc4ba",
+    "libdrm-amdgpu1_2.4.100-4+rpi1~bpo10+1_armhf.deb": "04f8d385d9cd48a9c3a3640b86efc5d482314c2bf89d82aaa9ef0ac46e2c4a98",
+    "libdrm-common_2.4.100-4+rpi1~bpo10+1_all.deb": "7db0fb4943ca45892e8a144db2d3f8dd0e89bdeceef27417e91a2ddabae53524",
+    "libdrm-nouveau2_2.4.100-4+rpi1~bpo10+1_armhf.deb": "8284f53f4be3f0c8e77b6b9ba2113bf9488d6dabb2f1da71eecc66feb4e52c6c",
+    "libdrm-radeon1_2.4.100-4+rpi1~bpo10+1_armhf.deb": "bccfbe5e722378fe3cd0f47bea54a0d624f267fddfa9bddfd3e9c7460ee0d300",
+    "libdrm2_2.4.100-4+rpi1~bpo10+1_armhf.deb": "e6c6246deca3edd815a471ad520ce0d35b1a20d1d722dfb77c77c5fdb03dd5c6",
+    "libdv4_1.0.0-12_armhf.deb": "d9e1418bbda8da1681dc2deb742979fd5c2ef647351ae38937d8e77fe0a33fd3",
+    "libdvdread4_6.0.1-1_armhf.deb": "e58e2dcae4e4438773c6acd760f45be9f114192ec981f60a758783d2c39c1930",
+    "libedit2_3.1-20181209-1_armhf.deb": "0d35fbdf5952df7a78dbc4776b89361a2fef8006342a94ab9d602483ad3578da",
+    "libegl-dev_1.3.0-7~bpo10+1_armhf.deb": "ed5321aaacf2ba419c00af1f87f3035ad884370680b34464f8d01eb99f81d04e",
+    "libegl-mesa0_19.3.2-1~bpo10+1~rpt1_armhf.deb": "6594901be722b2db115c0adb2f5aa64f5b951b1ead97de4f0c4d0640540f1069",
+    "libegl1-mesa-dev_19.3.2-1~bpo10+1~rpt1_armhf.deb": "a13a14175ffcd7b7071559ad447636523ae289cf617c738d9159bfc0fab1470c",
+    "libegl1_1.3.0-7~bpo10+1_armhf.deb": "da6da10535c26d24a05fd3ce72295d19761c19dcf096398f7fe3ff9b349ff878",
+    "libelf1_0.176-1.1_armhf.deb": "013c168e64666e33e431701f7b1d683d2234f39caa2d801e389ef69266e88167",
+    "libepoxy0_1.5.3-0.1_armhf.deb": "1c09ff3084a59f3fbb519ca43b3d5d2bd32eb2835ec1b8f5703d02ddfefef2fc",
+    "libepsilon1_0.9.2+dfsg-4_armhf.deb": "22394acdfe3159dbb6a17aca4fa4edc641c1d6f04c5eed09802b10f0cbd24a29",
+    "libevent-2.1-6_2.1.8-stable-4_armhf.deb": "b8bca67f980502877981d8891e751fa0bd879e785c63e2dd25b61ef629442adc",
+    "libevent-core-2.1-6_2.1.8-stable-4_armhf.deb": "24cd3b8e29650bd0e4b4efe6c1d770b1e75df9682c07eb3276fa22eb55276c44",
+    "libevent-pthreads-2.1-6_2.1.8-stable-4_armhf.deb": "cb009ff0d23de8d1de1972b712c210899fd5e4380027d9ac6846d5bb3b7e8c25",
+    "libexif-dev_0.6.21-5.1+deb10u1_armhf.deb": "526dd289e8d99bb3f49201b683a61b5ac7647324d8768c1bf03331ded08786b7",
+    "libexif12_0.6.21-5.1+deb10u1_armhf.deb": "e5cee943f2890b6678d87cba21a5b99326f81f7882ffd87db1b8939ce5c10a97",
+    "libexpat1_2.2.6-2+deb10u1_armhf.deb": "869f0de1b5548c13e395554f454dcd17398479e12b5b1e7079fd8e5246113365",
+    "libffi-dev_3.2.1-9_armhf.deb": "094236c2efc98622b1ea267a9e32b1d9204fb99f703d632c7291322ed67c410f",
+    "libffi6_3.2.1-9_armhf.deb": "dd24f5e9fa15e16c80c8a13869d63f1a1fbef153b63c628d09f9bc4ed513112e",
+    "libflac8_1.3.2-3_armhf.deb": "27801797c7ef803e2c8dcb78c3af09ef0eac5498c2f69cf74d162d2b2d549c34",
+    "libfontconfig1_2.13.1-2_armhf.deb": "3c9b6ab7c53742599ba2d43f67181b01b77442c0bd48539466e3a117c555e094",
+    "libfreetype6_2.9.1-3+deb10u1_armhf.deb": "84a520466752a39ac67acd32403fd00b18f41bf5477044e8475d643fdfaefd78",
+    "libfreexl1_1.0.5-3_armhf.deb": "42a5ad5b00b79271a9651cd0fa220e488bc700b691e3e9789b7b0d0c27219a5e",
+    "libfribidi0_1.0.5-3.1+deb10u1_armhf.deb": "c1fd57da1608f48bd699d853f0149e47bb21baa4d7328be5f87fb0f908a5ed54",
+    "libfyba0_4.1.1-6_armhf.deb": "331d150a88b29e2cc16139dc2ba3c1c77ab0fd577be4f2f08de603bbaec0e59b",
+    "libgbm1_19.3.2-1~bpo10+1~rpt1_armhf.deb": "482834d6f9e315327baf5cf8fb53e43c22dd26a9031d248e57cebaa56350c2ec",
+    "libgcrypt20_1.8.4-5_armhf.deb": "19ec0ba3e4d133ade463dedc1ca4f2b37344eab058213cc384ea14488a7272d5",
+    "libgd3_2.2.5-5.2_armhf.deb": "77e8999b903a4b576ae05f3c3776f69a0277a8200857aba6fa3bc8fb290c874c",
+    "libgdal20_2.4.0+dfsg-1+b2_armhf.deb": "7b4f71a576320aecbeadd11dbd507c5a6f7c9c519606bd30efa5e192183112c4",
+    "libgdcm2-dev_2.8.8-9_armhf.deb": "8b27b3ab3e2c265bd92c78aa39bc485f692da499bcf5ed0e2d9ff6b52d5d6eff",
+    "libgdcm2.8_2.8.8-9_armhf.deb": "e07feea0e5724c4ea9ab24af5dae2ba5bc0d3be20d6c9596b09f7067dd037768",
+    "libgdk-pixbuf2.0-0_2.38.1+dfsg-1_armhf.deb": "68dc44a106ef642247847657567890d7f36a4eeed16d2b7d1e7e733a0442a265",
+    "libgdk-pixbuf2.0-common_2.38.1+dfsg-1_all.deb": "1310e3f0258866eb4d0e95f140d5d9025cf6be1e3e2c375f4a426ccc2e78cf68",
+    "libgeos-3.7.1_3.7.1-1_armhf.deb": "2fd2fc54180965df1f3921ced9186de9e97204bc08f05558a48de4fcfcec69e3",
+    "libgeos-c1v5_3.7.1-1_armhf.deb": "6efa1978880f24e97214163972ff29f652ffcb8a2cebff3d17235704e204f57b",
+    "libgeotiff2_1.4.3-1_armhf.deb": "044798114f725f781ec3f2415bdf12bba85c4e762e6a2d93fff0508ab8fa2346",
+    "libgfortran5_8.3.0-6+rpi1_armhf.deb": "a5f5a383d8e617a11316ec335f83ee5bafade9cc7de5c9d83dc79f5c5858f9ad",
+    "libgif7_5.1.4-3_armhf.deb": "b88a0b203bf0f88264dd932ee13a52d28b1e92eb76bfbc7e62a124eae71f9de5",
+    "libgirepository-1.0-1_1.58.3-2_armhf.deb": "098e26c851ba98e524d1d1d653bdbf3b1a8b9db2e89bcb64002edd67c9598e26",
+    "libgl-dev_1.3.0-7~bpo10+1_armhf.deb": "6f175572bf7dab31f7126048d7db6f55b5436520152470ed4b7d5ba0ebc9810b",
+    "libgl1-mesa-dev_19.3.2-1~bpo10+1~rpt1_armhf.deb": "5adea93723a650262ec985c973c20be17a82270396bdd77713f9f80af0875026",
+    "libgl1-mesa-dri_19.3.2-1~bpo10+1~rpt1_armhf.deb": "b38ba38d29ebc3b1a4d32169d80d38d3a573acc8b2bcad7e66165984e64d75c9",
+    "libgl1-mesa-glx_19.3.2-1~bpo10+1~rpt1_armhf.deb": "2379d7521f06e2c8a63cec396e67e6cf29894b5e3c40bd67dfda4bb48711e670",
+    "libgl1_1.3.0-7~bpo10+1_armhf.deb": "213a14ca4796ccb33b855471827d7fcdc882180200704b05a7c75b6c4c46d267",
+    "libgl2ps1.4_1.4.0+dfsg1-2_armhf.deb": "61aa9ebb7c7205365cf6adb2318b4d8376e30f6dbed9271bdda63135e6d57c37",
+    "libglapi-mesa_19.3.2-1~bpo10+1~rpt1_armhf.deb": "71b954a60ceecdb99910b104a1bc2de63efcd7e50a241f8c9084940f685a85d7",
+    "libgles-dev_1.3.0-7~bpo10+1_armhf.deb": "116de498552e39c00bb1eb25a8d4772b9d13ef795e224dec6a5c29c06b0275f8",
+    "libgles1_1.3.0-7~bpo10+1_armhf.deb": "3fc494445ad07c6e03e7b12c090299ae1c1a231bd3615702e7bba10c6b0dfc17",
+    "libgles2-mesa-dev_19.3.2-1~bpo10+1~rpt1_armhf.deb": "fea4ca62a9c5fd22ae478ba25fe508fca6f0b80dc356e05826e2ef9fac44fdc9",
+    "libgles2_1.3.0-7~bpo10+1_armhf.deb": "d877d872bcc1980622f89704de4870399fa2788635e2c6ac3ccf7ded8e1ba4d8",
+    "libglib2.0-0_2.58.3-2+deb10u2_armhf.deb": "6c9edefc08726bc9e63b31e487c022db6b55dd710fe3e022e1a414a17f33328f",
+    "libglib2.0-bin_2.58.3-2+deb10u2_armhf.deb": "2427db6ecd7aab23ebbeff37d85fb955d181fa6fe07f03d4203dc994b0fa26be",
+    "libglib2.0-data_2.58.3-2+deb10u2_all.deb": "19982dfe0de4571ec99f683bd62c74e66c2422a00b0502089247d86c1c08ce92",
+    "libglib2.0-dev-bin_2.58.3-2+deb10u2_armhf.deb": "a708579413f3e56e358047cbcc0b4a64fcee8d40379e5c7b65a2a5e97e8db9be",
+    "libglib2.0-dev_2.58.3-2+deb10u2_armhf.deb": "c7c649b1a207e2ecd5f87d68a81722555ac0fc30a6de7456707cbbf33c14e2ab",
+    "libglu1-mesa_9.0.0-2.1_armhf.deb": "1a3aaf79151e412a4af3316873e8ae5f73a8e78ef7e361b37e49aed186470e91",
+    "libglvnd0_1.3.0-7~bpo10+1_armhf.deb": "716ae09c8196bfa9d23567464711869a79e8b32239504d5d344d8a89ca12ba2e",
+    "libglx-dev_1.3.0-7~bpo10+1_armhf.deb": "077828dc0770a2c5b0878a5110f767ebc345b2fd455689df5151bf3479ab1347",
+    "libglx-mesa0_19.3.2-1~bpo10+1~rpt1_armhf.deb": "c2f547332b4ccdc7aaf9816f0b5801deddc2a5fcce46a4d6820258d38dcd3e61",
+    "libglx0_1.3.0-7~bpo10+1_armhf.deb": "6a5592b4469520bae2a4465fbe903a9e17eab5a54cca3871a2da657a1bc41347",
+    "libgme0_0.6.2-1_armhf.deb": "09a4d473e20c1cbd76119c45a42d00fe953ea7a58cda45abaf65897bea82e21d",
+    "libgmp10_6.1.2+dfsg-4_armhf.deb": "ca3cd65e915de80716dd976fd9e6b9588342e39117ec07ac5a00e60bcb1a27df",
+    "libgnutls30_3.6.7-4+deb10u2_armhf.deb": "825f79632abeb0ac3c5c6de342a5c85fac0d804d82621a6abda3a88e2a7fa26f",
+    "libgomp1_8.3.0-6+rpi1_armhf.deb": "243f49f947c8a992ecb8c38a301288661254bc10099d27c98eafd2e05fe88100",
+    "libgpg-error0_1.35-1_armhf.deb": "6549092b313862bf3959fa4a0903a885ff81a777bed2b4925ab85df03588eee2",
+    "libgphoto2-6_2.5.22-3_armhf.deb": "b20dd5e04ecce954151680f4aa35e6f5a2c8c7f09a8bbfc5a769345d99481861",
+    "libgphoto2-dev_2.5.22-3_armhf.deb": "30b98ae9bb8fa42ce16e2231f509bf68c425d1bc81003ef66ed8fda1774fa135",
+    "libgphoto2-port12_2.5.22-3_armhf.deb": "0eae07c8307af1d629d475c9a50570e032941c6ef065b2551684b03dbc0e7c46",
+    "libgpm2_1.20.7-5_armhf.deb": "ecbbfd27d35af29066c8f0af5a0178742bd4121db6cc3a73c36f7d92ac087da6",
+    "libgraphite2-3_1.3.13-7_armhf.deb": "461cc0fec95f74dae2c031e7c7123774877e8bb4f0341b607d163ee0e58d1186",
+    "libgsm1_1.0.18-2_armhf.deb": "148dd82999418b9d1e70b412b5fe2d2e1d4de7407cc23ec7e2c485a7fd73ef57",
+    "libgssapi-krb5-2_1.17-3_armhf.deb": "63a06b5943840f841aacc34032974f228a3c0023fca05d9b4b6329650390361a",
+    "libgssdp-1.0-3_1.0.2-4_armhf.deb": "e9d0bc5dc4f7adf6708dabeed47fdaa20ff084d69354631320aece8bd1cdaf6d",
+    "libgstreamer-gl1.0-0_1.14.4-2_armhf.deb": "e1ec18f4cbdb6b73edb27e3a31df024f9841055faf2ba72daa0620515df3dffe",
+    "libgstreamer-opencv1.0-0_1.14.4-1+b1_armhf.deb": "e5ec50fd7dc603220480517f3e0c7dfcc41ec8cdc2102d83edb278fdd5db26b9",
+    "libgstreamer-plugins-bad1.0-0_1.14.4-1+b1_armhf.deb": "5ad37aebe6abdd5c64f13d3f4d2d07bcb99e236062997eef59eb27001030c480",
+    "libgstreamer-plugins-bad1.0-dev_1.14.4-1+b1_armhf.deb": "7fc2423d435d36c0ebdc7bd95ec65ca6f2d05e3d0b08db3e110fab21660972a6",
+    "libgstreamer-plugins-base1.0-0_1.14.4-2_armhf.deb": "617414a8a437506f147993f53fc512c6be6654ac9db842a0cdbdd9df0933fdcf",
+    "libgstreamer-plugins-base1.0-dev_1.14.4-2_armhf.deb": "4d6e6533676ad4239b4bccf3832ef041fff28fd3bbcb4d1625c830a1f2702f03",
+    "libgstreamer1.0-0_1.14.4-1_armhf.deb": "a02653fa3ca6b0c274360ab93ca68a4c313a29391017a641743a3259556c423d",
+    "libgstreamer1.0-dev_1.14.4-1_armhf.deb": "2dc305a1839f7eb92cf902865339f24af07756d0108be2676989d5f29b68033f",
+    "libgtk-3-0_3.24.5-1+rpt2_armhf.deb": "3ee5f878748e4a6301a631a1fc1e5afad3a0bc07cf5d2485e12511545609732b",
+    "libgtk-3-common_3.24.5-1+rpt2_all.deb": "eb65d4610b98e5927a23ce4f36bfd76e2d53e1303b94c6d2a0c634d8fe4506fd",
+    "libgudev-1.0-0_232-2+rpi1_armhf.deb": "6e7458021ddf02a5627569f2f67fc38eb0a5896080ad5b8e558b2813f0036201",
+    "libgupnp-1.0-4_1.0.3-3_armhf.deb": "6e38b555d6c945f37e0a56d8133007b448562a0a64e3998844c138c6c2e2a0a0",
+    "libgupnp-igd-1.0-4_0.2.5-3_armhf.deb": "fb0a64162c01d6dcd3d22d0af42839c112996d2f3cc983c9174512194dcca35c",
+    "libharfbuzz0b_2.3.1-1_armhf.deb": "cb57cfe0e2c3e36a9cdbf032eed11269eeda8ae5c66203fb95c19cc8c2fa1ed0",
+    "libhdf4-0-alt_4.2.13-4+b1_armhf.deb": "df376e0f0413e52cd59ddc937a4c9fde565cc4d5cf56cdc63f9c32c709ac8053",
+    "libhdf5-103_1.10.4+repack-10_armhf.deb": "ebe9eff643cb5e5fb0f78038ee81ae8a7ee29bd2e1d34eeb92452c3c172291ff",
+    "libhdf5-openmpi-103_1.10.4+repack-10_armhf.deb": "eb53ab0db447b08d50f3c8a5d22f8c643f65075ace448efe86d6bea5e194352a",
+    "libhogweed4_3.4.1-1_armhf.deb": "9eafecd38110191e285293a770eb13ef7a291cea2e0ff18cf511c6cf21b947b6",
+    "libhwloc-plugins_1.11.12-3+rpi1_armhf.deb": "5703cbe54214331b879aa8bc07577dc7e4e3c748df6a9c8f89af9e6e6e5cb20d",
+    "libhwloc5_1.11.12-3+rpi1_armhf.deb": "a9c20eeaa0f5abff444a3f12639ccb8554fae05d97cef1840e5de54c7d3c394b",
+    "libibverbs1_22.1-1_armhf.deb": "37aebd2d0c1cffe2b9a8678bbde786ae57b9e04ca8977fce5baa334378e661f7",
+    "libice6_1.0.9-2_armhf.deb": "92374e7e8076ad0062638c7438c886d0c23000b1a8a9b361a057d0625dc20a65",
+    "libicu63_63.1-6_armhf.deb": "94010cc7c8ce2de49ad2dcdf2d70eccb32b890a8d5e9b30ec5ba3ce72f681fdc",
+    "libidn2-0_2.0.5-1+deb10u1_armhf.deb": "48ca6a20d9901a78b714dc926b74371786b03ece5956ab4f78a148a74f4ad56f",
+    "libiec61883-0_1.2.0-3_armhf.deb": "8e06dd60a6e73bbddbcf2a4ec0c2ad72d97525c95481e1f6f92b2eff37b7d020",
+    "libilmbase-dev_2.2.1-2_armhf.deb": "bcd411d9f601549cbbb343b672e6ce0be2704c701f2cc6cdbc254cc8a8b61bce",
+    "libilmbase23_2.2.1-2_armhf.deb": "7d8995d3db7cfe4ff6705553d00679682f55cd4021436e7bd2e83bb56d23d8c2",
+    "libjack-jackd2-0_1.9.12~dfsg-2_armhf.deb": "3b67f2727dd9020c370ec00c693f575bb8540b7ac3f1f27e1e4285449ae3ccea",
+    "libjbig-dev_2.1-3.1+b2_armhf.deb": "8324e57714c0e44ed47235ef3510cd4f1acc8b098eb2140b7773935cfdd4a7e6",
+    "libjbig0_2.1-3.1+b2_armhf.deb": "b50783fe5974f648125b6ce2487ba05f99e4f11929f5b75bdc5baa94890a563f",
+    "libjpeg-dev_1.5.2-2_all.deb": "71b42025bdeb9fcc30054b54c84c4306da59466fbd419f46471f15ec54d435aa",
+    "libjpeg62-turbo-dev_1.5.2-2+b1_armhf.deb": "c8b85c158cff2deb164da3e67eba70fa13cfddc40ef7e721eaa4bf0c770f9194",
+    "libjpeg62-turbo_1.5.2-2+b1_armhf.deb": "bc28dbc5b68fe0268aa7692562bb0a39908e1bd0901be1990affd585fec773b3",
+    "libjson-c3_0.12.1+ds-2_armhf.deb": "ca3de6f029fb22f0efb576734f27a97583ebd9b9137b1c7cfd0f6228fae44423",
+    "libjson-glib-1.0-0_1.4.4-2_armhf.deb": "a790c43ed7957d646337df29628b17e812869b1e087a59002f5b1b97a42b400f",
+    "libjson-glib-1.0-common_1.4.4-2_all.deb": "c27dbb0cf9c73e2a09d5c774fb46ecf6d2b634facaf3b37b20a4654d9c549187",
+    "libjsoncpp1_1.7.4-3_armhf.deb": "25674de33c2105228048b9380b71045faf0716e63c3f901f4d9bc67ed4579c8a",
+    "libk5crypto3_1.17-3_armhf.deb": "abcc38ec1ec6f0c84feb2cb14b8a96517957cbcbdc20f6183e7fe3c0e133975c",
+    "libkeyutils1_1.6-6_armhf.deb": "ee0948ea16c2520d5a8612ba74c95c820966ed8dba78334729aef37571161d58",
+    "libkmlbase1_1.3.0-7_armhf.deb": "7ffa17e6e3487fd5745d32416ff82dba541b926b9eaab2e16ac7811a38de2486",
+    "libkmlconvenience1_1.3.0-7_armhf.deb": "4bfcc0187e12a3eef08372c3b8be8205d4eecddaaf4d7467ce29585466bc2365",
+    "libkmldom1_1.3.0-7_armhf.deb": "168b96f0e36b863517afc16ea6a37f00acb20dac80a40ffe2a6039412db0630d",
+    "libkmlengine1_1.3.0-7_armhf.deb": "d1d5df02935b20105d94e9ea8d4d1b186d3592f9197d9bea36d69b2cc2952d80",
+    "libkmlregionator1_1.3.0-7_armhf.deb": "3eba2098651bd33e7a51e7c54f9996ac11f0167c133ce59ddea4415ad7f5cecc",
+    "libkmlxsd1_1.3.0-7_armhf.deb": "820b7705568f69c54b7ac30feb9bc36935aecbbcaac55a801b6675f1bfe1a599",
+    "libkrb5-3_1.17-3_armhf.deb": "eb91711bd2f1606354c27216c89cef3c85d78407902b750ee228018f9134f8a1",
+    "libkrb5support0_1.17-3_armhf.deb": "5b0d26f4a7f8a0991087b917b2a9d93d353c4c9cc18f6a345db45e1c06391564",
+    "liblapack3_3.8.0-2_armhf.deb": "b6b2d62fe5f607efbb383d5b39edffa414a1bdad89cb886a60e0b5ee55c8ecbd",
+    "liblcms2-2_2.9-3_armhf.deb": "6d771698dd7b90af8f53d744775ad0f8a669be7a5ee8bf2c285f7bced0c64822",
+    "libldap-2.4-2_2.4.47+dfsg-3+rpi1+deb10u1_armhf.deb": "b61e759ffe122e843dd2b5117a421fcd344deac94c75b1892e338ab6042ce4a9",
+    "libldap-common_2.4.47+dfsg-3+rpi1+deb10u1_all.deb": "16f2cc9f5faaf9a539697d8adf05c0f460d274d785497aa8027dca6b0e9236d0",
+    "liblept5_1.76.0-1_armhf.deb": "9eb19fa5d74b861bdca63d195e9f23c90f359e6702ab2140df36804d7098f495",
+    "libllvm9_9.0.1-6+rpi1~bpo10+1_armhf.deb": "5b56393c34757cce6e0a6e825ef49aada4cdf3b676758dd5e8b1756ee63bfacb",
+    "libltdl7_2.4.6-9_armhf.deb": "0109cd8ee5f2216584d21dcbb8b85786d5d38cd3d88fa8602c756088c38ba29a",
+    "liblz4-1_1.8.3-1_armhf.deb": "99661a8b347d55fc0212b8176f691eaee1e13e2ee75aa316c549ac669fe77925",
+    "liblzma5_5.2.4-1_armhf.deb": "825babb4ce905472493d6f26a5ec6dfa055447f3a9f4b3418cec9e0d56681f03",
+    "liblzma-dev_5.2.4-1_armhf.deb": "94c1b419a70af792590eb26582f3ab5fd6908ee0f045ee649c65523503290bd4",
+    "libmariadb3_10.3.22-0+deb10u1_armhf.deb": "8128c49aa661b270d351afe881e9a8081e3fb6706ae66b5b2977ba51acd5dca3",
+    "libminizip1_1.1-8+b1_armhf.deb": "7ac58a7fb21b641d00d5485c0068ab4aca024f795ee220eec5ac1501cbfe6b7c",
+    "libmount-dev_2.33.1-0.1_armhf.deb": "24c59b7b33df451c7c3eca4b1d39a25c2e26eca4d4ee6b47331382175307dc11",
+    "libmount1_2.33.1-0.1_armhf.deb": "9443056463d7ddedde9bf28e1f2b6486198b68143fa0b7a2688e3edf823d566d",
+    "libmp3lame0_3.100-2+b1_armhf.deb": "1b5334f976afe0a16c0faa29832ff35e6d442beca23062b9f385079a120d4017",
+    "libmpdec2_2.4.2-2_armhf.deb": "6e02dd1398652b5d49defa6e2e05bd209d47ca08ff7c2d5801afe044f2a7792f",
+    "libmpeg2-4_0.5.1-8_armhf.deb": "0d2ce617542f7f56073c12c9b51562059b8d10c191016274d4c5f582b94e4d62",
+    "libmpg123-0_1.25.10-2_armhf.deb": "e552789597110f8cc7300ca34578a2e93700db189ee4732c2adce39a339ad617",
+    "libncurses6_6.1+20181013-2+deb10u2_armhf.deb": "89e79e7be6f1a61e8b5f3d05f12933e9b9f9b0b728ecfa91bf64ae03e3bc421a",
+    "libncursesw6_6.1+20181013-2+deb10u2_armhf.deb": "2435c3c7d6f27d907584a36583da629927eec4c2d8e2deff7bc8d814ff2b97b6",
+    "libnetcdf-c++4_4.2-11_armhf.deb": "ddbc876f3a37f78386f7d4611ad9ef095dce27a8dffa95f65a64c10381324d27",
+    "libnetcdf13_4.6.2-1+b1_armhf.deb": "0323f376ec2d0be39683adfdebaba1a0ee062d4387a4b1cd5946b389b6fd0409",
+    "libnettle6_3.4.1-1_armhf.deb": "49010bb7544c086eb20d5330fd1b1bce61bf29f66f0bfe7da5381f1ddcc6abf0",
+    "libnghttp2-14_1.36.0-2+deb10u1_armhf.deb": "3e47c770b48f555decbb31bc38f38b985c8d6009f39f7923c0fc7973bac99348",
+    "libnice10_0.1.14-1_armhf.deb": "5804c3e12b944271420f92f8df0bb32dc78bbc0a11058cbfc2a614d5a9108866",
+    "libnl-3-200_3.4.0-1_armhf.deb": "61c07f733be04122faa5f86e50138f27b639b10852fa19c5109b63ce7b4f1d8d",
+    "libnl-route-3-200_3.4.0-1_armhf.deb": "3761f4d6c6b255873b5ddf9c615ff9c396f00b212bde9d81cf83a86373316b44",
+    "libnspr4_4.20-1_armhf.deb": "1a5c311c0b2d3de1d53bb8bed8034c475dcd8293319e69f4bea2d765f00c87ee",
+    "libnss3_3.42.1-1+deb10u2_armhf.deb": "bf52021aac6e4c10183f10155fb554286831c75639e766c19c0f4946cde76718",
+    "libodbc1_2.3.6-0.1_armhf.deb": "07ce132f8fc2dab2e11f6988896cfdaf2e865b81da96456f42fde8f5e1e1708f",
+    "libogdi3.2_3.2.1+ds-4_armhf.deb": "f2089377ed36ef36327e8a982ea3fdde736806fd7288be67da19b69a7d1f6bb1",
+    "libogg0_1.3.2-1+b2_armhf.deb": "2518b3214e3c709eb0df6bb71127d1b9e24fc642513f6a8a9e729de98f789d50",
+    "libopencore-amrnb0_0.1.3-2.1_armhf.deb": "59818224c4950a1ea304368783dbfc5a8b4497566cc42af6b5e0884134579f23",
+    "libopencore-amrwb0_0.1.3-2.1_armhf.deb": "a687b84cd6479fbc1a74c96556f6e468e7d2f46a9f674bccf1ac4005a6d1184c",
+    "libopencv-calib3d-dev_3.2.0+dfsg-6_armhf.deb": "8c7f3ca52bf148f39483a6e1ed864c36107f5461fed78934b9ae3cecf027e48a",
+    "libopencv-calib3d3.2_3.2.0+dfsg-6_armhf.deb": "a7ce99efec8b00d8db399352a7099ab78153d5aec72fb1f53d3570b6213d1c4c",
+    "libopencv-contrib-dev_3.2.0+dfsg-6_armhf.deb": "b733091fe4bafb84f40b1221af788ec5df7f64108bd15c700575054a9846d1b0",
+    "libopencv-contrib3.2_3.2.0+dfsg-6_armhf.deb": "41ce0e6af765c46d2fbfd9d9b8ecca678537e53ac637dbc28775f26b22b18d49",
+    "libopencv-core-dev_3.2.0+dfsg-6_armhf.deb": "a83d0f59ce1e23cfa2f7c400e669f12b905acbbc9349998b9eab451c78ce91ca",
+    "libopencv-core3.2_3.2.0+dfsg-6_armhf.deb": "d2b7ecda65da3ba6610711dc9ab95f7bc8f90a6dead77ad06f93a082b5ae36f2",
+    "libopencv-dev_3.2.0+dfsg-6_armhf.deb": "aa519c3e572b655f039803117c737bc7c0f0638fbc86ff8989294b5df294a8fb",
+    "libopencv-features2d-dev_3.2.0+dfsg-6_armhf.deb": "b614de275538bcb5a12ed7bc9cf7dc644572b1792cab7f5c821d329fbf05ae54",
+    "libopencv-features2d3.2_3.2.0+dfsg-6_armhf.deb": "2acd7864a39c01528f87b8d34fb5b620004e04cc287200c74ca44e0712a161b2",
+    "libopencv-flann-dev_3.2.0+dfsg-6_armhf.deb": "b81522782181f3d39d48a6b61b3b61fa45388c305ab7952d98fd7b6084314e5d",
+    "libopencv-flann3.2_3.2.0+dfsg-6_armhf.deb": "097da5fec0d3828e7e2de1bd1d38cccf86c3e0f866a94e9ae0f116fe69afdace",
+    "libopencv-highgui-dev_3.2.0+dfsg-6_armhf.deb": "20c31e48c84f7ac8ff74e603aa91453671fe0f13292f5c05370ce7c984eaeb76",
+    "libopencv-highgui3.2_3.2.0+dfsg-6_armhf.deb": "f52232ca0db2aec76bf55605f7268eb3f5969524d0dd4627a5e0c75900655b38",
+    "libopencv-imgcodecs-dev_3.2.0+dfsg-6_armhf.deb": "055d2f33c8b1b20edc0d989a6ff047d0b9eea0347237febbcf27f9380fc1b843",
+    "libopencv-imgcodecs3.2_3.2.0+dfsg-6_armhf.deb": "3a87d0dd4a0d534242394de932526365a9e080f9fe783a1caaaeb72b909762c0",
+    "libopencv-imgproc-dev_3.2.0+dfsg-6_armhf.deb": "0069eb4e75c2133ca12b94f979e5c2ec1c4be31b7ca42e39a90200bbb287f4c8",
+    "libopencv-imgproc3.2_3.2.0+dfsg-6_armhf.deb": "2561604f98264ade28e5ecb31b1e5590fab4c861bb170de41e8533d09dd868c6",
+    "libopencv-ml-dev_3.2.0+dfsg-6_armhf.deb": "f576a5bd460c64914e6091d5229ecf5a021a9541319d5dae472105f2d3c6e3aa",
+    "libopencv-ml3.2_3.2.0+dfsg-6_armhf.deb": "f187fa8c4cb52c982a19c5199b4df4d311bb19a561744e9086a46b4f40de69f9",
+    "libopencv-objdetect-dev_3.2.0+dfsg-6_armhf.deb": "5a1e49091efe0af562cbbc3fcd5035c4770d076503f4266360528b3aacd170ba",
+    "libopencv-objdetect3.2_3.2.0+dfsg-6_armhf.deb": "a908f56acfd787d76ab91bf3e10374c6c34070fe73acf0b58683d15d845bd5ce",
+    "libopencv-photo-dev_3.2.0+dfsg-6_armhf.deb": "6f93654b78007bb54b6294a6294d2ee1b2c8c34f9557f7fb6f51caf8a996680c",
+    "libopencv-photo3.2_3.2.0+dfsg-6_armhf.deb": "2dbb93becd211a9543711c99c32a9f6e7480f554c068a945bd76c20111756207",
+    "libopencv-shape-dev_3.2.0+dfsg-6_armhf.deb": "a56b63c6706af19b3f6e556ee7cac51dd80af48d948f7226bc5d60d4d57dda16",
+    "libopencv-shape3.2_3.2.0+dfsg-6_armhf.deb": "a6906df95067c61b18ebdbe36e30e836752c2a4c1b6a4160b1dc991b347cbe34",
+    "libopencv-stitching-dev_3.2.0+dfsg-6_armhf.deb": "d343a82f4190e0cf10ba72846d01fd38a132f7e22024f8e8ba19171c0a65feab",
+    "libopencv-stitching3.2_3.2.0+dfsg-6_armhf.deb": "e8abf81b53d28ee5e68ae5d6e423a1278e0619b02920efbc247665b5b7bbe497",
+    "libopencv-superres-dev_3.2.0+dfsg-6_armhf.deb": "24511a36a510be5943842931933577334b4e8410ded4be3fe6ad634831b5baba",
+    "libopencv-superres3.2_3.2.0+dfsg-6_armhf.deb": "81e8882fbeeae7d07665c6c07e7885b5f43fdd7d536b7007e298cdeea4acc510",
+    "libopencv-ts-dev_3.2.0+dfsg-6_armhf.deb": "2e9520d3c83ac2ef3af690ff4241c68a8cad067c0cc50d3ec9395ac7d75e29dc",
+    "libopencv-video-dev_3.2.0+dfsg-6_armhf.deb": "c7ae7ced16c7cf6aa1a1647758b0c1cf01e38bf84444dbd3baf568d4328c6f86",
+    "libopencv-video3.2_3.2.0+dfsg-6_armhf.deb": "e6d079903ce88b25558046b4ce94261eafd2fb5de0617e7fcffbbef02521ac59",
+    "libopencv-videoio-dev_3.2.0+dfsg-6_armhf.deb": "f712aa3626fd0efc42240c1b500e05a37f8e05bfab459046a6a1cf2364541127",
+    "libopencv-videoio3.2_3.2.0+dfsg-6_armhf.deb": "ed38ad4aded75bc4b5ee1a2e7acc67fc0a7a0484d9d5fe46e56f5a9edaafeb57",
+    "libopencv-videostab-dev_3.2.0+dfsg-6_armhf.deb": "942519168d7be208736394024612285bacc9c41f66edcce5a33eb86aedae6dfc",
+    "libopencv-videostab3.2_3.2.0+dfsg-6_armhf.deb": "a4dae91092fe9e9e60b2c185d610a15452f7f9df9b9b635e8deaa3b0aa93cbbf",
+    "libopencv-viz-dev_3.2.0+dfsg-6_armhf.deb": "64a9b47eb603860c60fe62f4024b3f23a4df23fe7a0e185090ba730a32ec7fc2",
+    "libopencv-viz3.2_3.2.0+dfsg-6_armhf.deb": "e3a859dc1426c7eddfb181f0e37c8c20bebced557fabf5161de795195c12c9b4",
+    "libopencv3.2-java_3.2.0+dfsg-6_all.deb": "6a177762d8dbe7e2a54cfc03aa523802848e0567ded674314d1919652b07f81b",
+    "libopencv3.2-jni_3.2.0+dfsg-6_armhf.deb": "4fae611a082c059c2344d4f39ad60d3c00c79e243b3e218d6ac5fa5a829c63bb",
+    "libopenexr-dev_2.2.1-4.1_armhf.deb": "fb634227cc4fb67662fd45a8a5e741dd9609a2872a841856cd21c20aa7f4d0e8",
+    "libopenexr23_2.2.1-4.1_armhf.deb": "437f125bc53e5749d32de0625f8aaa4eb3c06df096ce147889cf9bd380876dde",
+    "libopenjp2-7_2.3.0-2+deb10u1_armhf.deb": "74219a03fad8c3a64cebbf9d4d82f30e365ad7e80dd5c100eae0a8d63ea1b5b0",
+    "libopenmpi3_3.1.3-11+rpi1_armhf.deb": "b6d19977698ae4860690574ce43dd947462e41ab96498f6cc557c4a122ad2cb7",
+    "libopenmpt0_0.4.3-1_armhf.deb": "85eb98a60a45992c9345583c5869a124a71e6d9179737bc7ad5597c615b08530",
+    "libopus0_1.3-1_armhf.deb": "69cd56d03aaa51a4d62ad8f98d2ff487ea062bbdfe13e983afcefa99cb0c010e",
+    "liborc-0.4-0_0.4.28-3.1_armhf.deb": "9c66d1482f30f0fa8550c0c0dc4931ee756c3ce6a09519bc1c65080c51f3c470",
+    "liborc-0.4-dev-bin_0.4.28-3.1_armhf.deb": "a25a84b79c4127e7065706e2e06966cd358d53ed245b1ac8a80f93c2169d1dc8",
+    "liborc-0.4-dev_0.4.28-3.1_armhf.deb": "d24d100bdd75dde0f0338a80b8293200f7a838a0fb1d3760e887e6e3fa0d163a",
+    "libp11-kit0_0.23.15-2_armhf.deb": "56de64f62447b20b4f24f3c1d5cf2036f0971f22e1e820e25ff16b8cf59a7490",
+    "libpam-modules-bin_1.3.1-5+rpt1_armhf.deb": "d10f1ff2fa6e1b486e2d1443793ee86eecaa15db9487f553e659696d4a9c7e01",
+    "libpam-modules_1.3.1-5+rpt1_armhf.deb": "a7294f87afe55e0972ed7bba8269f62226b53824a6e0f25a8348776173be0907",
+    "libpam0g_1.3.1-5+rpt1_armhf.deb": "3f85873f6bda68084c597ccc7ec985cb5406b5335eaf0fd225ecce892d7c24dc",
+    "libpango-1.0-0_1.42.4-7~deb10u1_armhf.deb": "23d2b3f5e3ba20bc858adcd1e1718e1794ab34e7d50050d8af0f22c64d4c2afd",
+    "libpangocairo-1.0-0_1.42.4-7~deb10u1_armhf.deb": "a66aa6ac56c5d0f62d90c3015f2c9d8b6d40bbe00d0e2edc3f7ee14b030ae400",
+    "libpangoft2-1.0-0_1.42.4-7~deb10u1_armhf.deb": "40cd486567b4207f2fe367d704a9ad6224c3e032129df5d6cb625bd3435a3bb8",
+    "libpciaccess0_0.14-1_armhf.deb": "37f01b81f204bfd7ab1ffbd3e4f2ef1355dd0f65167e8081ac3639bf12af912b",
+    "libpcre16-3_8.39-12_armhf.deb": "74a5968f6a046b48f020d171c0c67a9eea9614b29cb94facc72355529f4bb86b",
+    "libpcre3_2.8.39-12_armhf.deb": "394b0ce553f25fe1bcca1ab367ac86e374c30688c213f95c50f62d0c9101a9df",
+    "libpcre3-dev_8.39-12_armhf.deb": "6f7fe34a15f0c3522c9517ec79444c2aa0a4d952011a40dcaa124ba42ee95ae7",
+    "libpcre32-3_8.39-12_armhf.deb": "8fcd332bd8b2a8f1f4df2120bd33587f8366c708ce09da4904004dcdefbd933a",
+    "libpcrecpp0v5_8.39-12_armhf.deb": "286b0295ac923a822307a03bdc0ad7d408633fb4da4af3311ea74af54cf960b2",
+    "libpixman-1-0_0.36.0-1+rpt1_armhf.deb": "e24b5249c31dcccc246a88df767cc1b05ad47c98d484773f9e18982e1b3c2739",
+    "libpmix2_3.1.2-3_armhf.deb": "dc28717bcaffa242bc81a4e55d37819fdc73d6e204303555cf836f85973ab1e4",
+    "libpng-dev_1.6.36-6_armhf.deb": "91d8e235856389d40018e6a1568cf23c7f22c8a8fb076e9d9515ffec7159a676",
+    "libpng16-16_1.6.36-6_armhf.deb": "e5d547ed5bcc30045e8812602324c41a8e59536bed73d2af0405cbe3b596eb44",
+    "libpoppler82_0.71.0-5_armhf.deb": "78add7ce54ba679fcba6a87545ff99ed4a586c506642982caad8b529f60a6cb6",
+    "libpopt0_1.16-12_armhf.deb": "260b2ba983c6489f86cbfa590316b6e4fa3ba7501bfe9475f00c46fbf3ee76e4",
+    "libpq5_11.7-0+deb10u1_armhf.deb": "7a147de888adf44c51d604fbca0bb4341284154571cbcc1c83744f4536ebe970",
+    "libproj13_5.2.0-1_armhf.deb": "01226abbfaf179ce9f19397ee085bced5a29ee89e8af012b817196b8d173a857",
+    "libproxy1v5_0.4.15-5_armhf.deb": "6786d3190e0ab7069b207679d93b9d2f204aeb091aa87cbf0b899902521c7407",
+    "libpsl5_0.20.2-2_armhf.deb": "e4d0c0fc1b232cc3aee36351a474d55e56c45c587edbb4e3b4ce58ef399bdc3e",
+    "libpthread-stubs0-dev_0.4-1_armhf.deb": "296cbc4e83aa79186551dcd8dabafed34fc92eb376b425b93fc01b3aa02b9791",
+    "libpython2.7-minimal_2.7.16-2+deb10u1_armhf.deb": "e84407a0d58e7dff3adac497db1519dbdeba952a7caabd4f7ea2a14abb0e346d",
+    "libpython2.7-stdlib_2.7.16-2+deb10u1_armhf.deb": "dd2479f925a3da9b605b8dfb5a14ff58642e450252d7d4d99f05ca249c0d0280",
+    "libpython2.7_2.7.16-2+deb10u1_armhf.deb": "d5617bddfb0927d53471aee0ce553f22786fa488725ed09c22c13ffd8d97d884",
+    "libpython3-stdlib_3.7.3-1_armhf.deb": "9e9d450c4563f8401ac61572ce8ab64224c50c70fb2167462ae91b65ae5be5c4",
+    "libpython3.7-minimal_3.7.3-2+deb10u1_armhf.deb": "c3ba76c44d24cc3c43476dde183a7b622aad7ce3c1417512b9247604e030449d",
+    "libpython3.7-stdlib_3.7.3-2+deb10u1_armhf.deb": "d08ef59f65a9254fc0ea3c2ab4969177f8f88a21279ed8ff404f3d9b519c846f",
+    "libqhull7_2015.2-4_armhf.deb": "498f825e3c31489dc47fb9312110333ebf8bad5f1e1fd850a312fff4694f6a92",
+    "libraspberrypi0_1.20200212-1_armhf.deb": "8d5b7a46b7896e1f533f2c69384e1aedfc49e3c88d04f949fbe72504dd25bd18",
+    "libraw1394-11_2.1.2-1+b1_armhf.deb": "e7691347dfdc9096a69068f22a2f88a81f132e1cb0d1619cce89177a79fd02aa",
+    "libraw1394-dev_2.1.2-1+b1_armhf.deb": "23620ea90abf64a75431beb2939a129473fb9de4ab1f6b6fe9a414f85abc7b53",
+    "libreadline7_7.0-5_armhf.deb": "f655bfd17328343631ea6dd3fc7d885184a518fa397881f4d32f2a30b1e8fcb5",
+    "librest-0.7-0_0.8.1-1_armhf.deb": "ac4b777c967ae0f31b6d1ff51c32c8098c9d17e742ebdd2cbaa152b6f375e820",
+    "librsvg2-2_2.44.10-2.1+rpi1_armhf.deb": "9bfade393582432caa8f96868cd2a67b974ff04b9dc94a266e1bf578d14b124b",
+    "librsvg2-common_2.44.10-2.1+rpi1_armhf.deb": "02d96caf56f77643744d9d902c0d413b50224ad1a95757da65ddc2471dbb6cd0",
+    "librtmp1_2.4+20151223.gitfa8646d.1-2_armhf.deb": "c4adf4780f3e19b55fba417a0edc8d0d3b40be6d61c996a23d1a60cc3d1a3980",
+    "libsamplerate0_0.1.9-2_armhf.deb": "0476547c88c784cac2be1d75a5c7aeb4485a2e94e2d2b27b2c21fbb686bf0744",
+    "libsasl2-2_2.1.27+dfsg-1+deb10u1_armhf.deb": "49d240ab934a6433ee4a4d5130bb0147004cb2ae7752777bdc592dd920384b67",
+    "libsasl2-modules-db_2.1.27+dfsg-1+deb10u1_armhf.deb": "8e85cc998b555833ca226637bdde423667ed3eae531221063a2598c0203aa74f",
+    "libselinux1_2.8-1+b1_armhf.deb": "cc2fee966330b3d362358434ae60fa08dd7dcec81b606f4ac94ce83dd6097a39",
+    "libselinux1-dev_2.8-1+b1_armhf.deb": "662c07974f8f417921d39f23e2cadfcbc4fd386e3d1d763578572a134794c1ac",
+    "libsemanage-common_2.8-2_all.deb": "fa3c50e11afa9250f823218898084bdefea73c7cd1995ef5ed5e7c12e7b46331",
+    "libsemanage1_2.8-2_armhf.deb": "7f403dccd00375eb91786db9fbea41496833cb9391f78bd6ea1136d83203b325",
+    "libsensors-config_3.5.0-3_all.deb": "a064dbafa1590562e979852aca9802fc10ecfb6fda5403369c903fb38fa9802a",
+    "libsensors5_3.5.0-3_armhf.deb": "695f500a247e8a7762fe044c6fd9081db2e9806818eb4cd0593075de53ad5f5f",
+    "libsepol1-dev_2.8-1_armhf.deb": "bb83006408fa724bd51bb7c680bba624db2201e36dd546167ea40ced0a4b3aa6",
+    "libsepol1_2.8-1_armhf.deb": "9941f76c1d378ed0322cb413e0340455fe812f6b7451cf86a78065b2e5db69ef",
+    "libshine3_3.1.1-2+b1_armhf.deb": "7853acc136660422b7d3423caaf2ed5cb526001bb5064f932dfedf702fb5a35b",
+    "libshout3_2.4.1-2_armhf.deb": "436495384e51adf81b73943e46d1447adc7bac54bf03a2af6a6f7fe932380f42",
+    "libsidplay1v5_1.36.59-11_armhf.deb": "37f89d02cc1cb5fad7617d933eae81ee55261807fdaf45a01b49ec10595adccc",
+    "libslang2_2.3.2-2_armhf.deb": "b282110d4662728174929b22fe52d2a43a58791b6c967de29fb22c589578640c",
+    "libsm6_1.2.3-1_armhf.deb": "92eccccb771f738c18bec33b38c2bf95a281e216608e91341a7e2dbb1f8703fd",
+    "libsnappy1v5_1.1.7-1_armhf.deb": "8b87dfb35872804edd1fd002383762e593e54e3860123d0089a5b7bb26b8aef9",
+    "libsocket++1_1.12.13-10_armhf.deb": "64af2171d010a98d3cb8ca200ce24738a8fb92ef057f6b4d0c059885bf233531",
+    "libsoup-gnome2.4-1_2.64.2-2_armhf.deb": "f36e6e41e88d1ea5e203fcd1a833ef0198693a2156a6abc4a29baae817746073",
+    "libsoup2.4-1_2.64.2-2_armhf.deb": "6ef422515aa22db398887e4b0efaaeeb980a3e0d27ec1dbe3199a186d6ac19fc",
+    "libsoxr0_0.1.2-3_armhf.deb": "82c3a5098221423a3213cb7754758034e24ff114ca4e8562bf37038efc7e8afd",
+    "libspatialite7_4.3.0a-5+b2_armhf.deb": "26db41b6b1f2fee9a39673e624fe74172cc4a12b4324737dd7c066b2ae205098",
+    "libspeex1_1.2~rc1.2-1+b2_armhf.deb": "a05502ef24e63edcb3410bce0fb654c3d5a8d3129df7cfe60e0e2a330ddbc114",
+    "libsqlite3-0_3.27.2-3_armhf.deb": "09efeaead3ce02fe3b390952a30c2207be518acdcf0210715595c486212dbe53",
+    "libssh-gcrypt-4_0.8.7-1_armhf.deb": "6e8ee452c5c3fede30ee89ab80f95532f63614a76afe3d138213e33986df768b",
+    "libssh2-1_1.8.0-2.1_armhf.deb": "ab4159f8bbd8491349d75231d09bc2fdca61f91756abaa2bac95210cfc21d310",
+    "libssl1.1_1.1.1d-0+deb10u2+rpt1_armhf.deb": "56d621416c4ee9accbd92739b513c72c3d984dcfc77ef3c066d1e1a4fe177ece",
+    "libstdc++6_8.3.0-6+rpi1_armhf.deb": "bfc0533cc7d6a4d8adfb62205b39a79ee6df7c2f7c48a1dc6ff15f5af519aed4",
+    "libsuperlu5_5.2.1+dfsg1-4_armhf.deb": "f4d797c904bbedb0ea341bd7667661137004403a86a2a8b3e7d1c2365d08dc35",
+    "libswresample-dev_4.1.4-1+rpt7~deb10u1_armhf.deb": "47aa45f988faa21fd8815ffea72fa4dc086a9e7992e32f1d9522d424ab1f4256",
+    "libswresample3_4.1.4-1+rpt7~deb10u1_armhf.deb": "d50c0cbac33b70edb77e01844b9eda8f26a02d8e060ba8ea010e638407e11de9",
+    "libswscale-dev_4.1.4-1+rpt7~deb10u1_armhf.deb": "566ca37b17fc19bccbdaeeb350dadd0081428c369cf344e36f34fd3060366d79",
+    "libswscale5_4.1.4-1+rpt7~deb10u1_armhf.deb": "cd1659a4fffca19203a7f018ff167b2aa4fb2ea0fcaccdb2340b16ae41c14d28",
+    "libsystemd0_241-7~deb10u3+rpi1_armhf.deb": "a339e885c19f2922deb7dd5f212ab4f15c209a5fe99c8333041d5f19abfbf475",
+    "libsz2_1.0.2-1_armhf.deb": "ce5347b6d722e01899fc49a39073da7a16985ceadcf8238985e8109617a2a11b",
+    "libtag1v5-vanilla_1.11.1+dfsg.1-0.3_armhf.deb": "0a1bc26966e18900082e2fb6c730a4c10d7995c01599ae0ee378a153965bdfbe",
+    "libtag1v5_1.11.1+dfsg.1-0.3_armhf.deb": "e6b60a8a839d5df43ec2487ad3643d0c796acb51ecafe5ed6fc4c65ef02e5365",
+    "libtasn1-6_4.13-3_armhf.deb": "594f82946858a332bfbe55ddb2b10247a52486b8b183fd818231fef8a70ff682",
+    "libtbb-dev_2018~U6-4_armhf.deb": "ff7b27eae8c89056677a0479667448c0a2d8e20f75ed84862ccc183d9739ae7c",
+    "libtbb2_2018~U6-4_armhf.deb": "4ed379b2c64bdc16b6cf1cff7b0b859c125bfc311ebfa933f17c8f6efb8f65af",
+    "libtcl8.6_8.6.9+dfsg-2_armhf.deb": "b0f0b25f4bdbb95020ed1476fbc9a84e9a22b3d5278c0dd3df4a5963b5daf3f1",
+    "libtesseract4_4.0.0-2_armhf.deb": "1f46f21a995d76aa42c83ea6272876292520d04a51936fbd4752811ea5e73be1",
+    "libthai-data_0.1.28-2_all.deb": "267d6b251f77c17fb1415ac0727675cb978c895cc1c77d7540e7133125614366",
+    "libthai0_0.1.28-2_armhf.deb": "dad127d817507db95d10a5010db28cef882b51567d5fae58da97fc7bed55f7ae",
+    "libtheora0_1.1.1+dfsg.1-15_armhf.deb": "92f9de0685e30d293e113072b429651a6b2f783c23ffdbdc430da851e9f48236",
+    "libtiff-dev_4.1.0+git191117-2~deb10u1_armhf.deb": "814eae7eac7d49370ac8bcbfe0d129bc9c57ebbd0df8b0da4cdbabec68a8415a",
+    "libtiff5_4.1.0+git191117-2~deb10u1_armhf.deb": "723b155bbe6844483a7a3dc6b3dbd391d18eb5ba405e1b2fa6d3886864a89cc6",
+    "libtiffxx5_4.1.0+git191117-2~deb10u1_armhf.deb": "2533170a4fe4b0d67924819941384eb21ef9790ec8f88f9e621aad95d0c50d5b",
+    "libtinfo6_6.1+20181013-2+deb10u2_armhf.deb": "48f25a4a8c6629126aa77d9665030b83867f520e50cf8317249e22d8ec204963",
+    "libtk8.6_8.6.9-2_armhf.deb": "d15d84339d668d91cc78e66122265fbccbb56f2ab5b37f2792f3112e44b9dded",
+    "libtwolame0_0.3.13-4_armhf.deb": "2fc0bb23e5ba08b77fce5651d9c3b536478eebfd00ff8078633187538b8bdb4a",
+    "libudev1_241-7~deb10u3+rpi1_armhf.deb": "14484556224a1c659202f91f7903166b899870e9f4602117944d69fcd8849e51",
+    "libunistring2_0.9.10-1_armhf.deb": "7e9a8046fde4a3471e9f5477bdcecd079e423aff2b916791e0d4a224e5a6c999",
+    "liburiparser1_0.9.1-1_armhf.deb": "ed680831b4a4236a27707cd50d4649fd812876eccf1f1bfec772bb9255f65cba",
+    "libusb-1.0-0_1.0.22-2_armhf.deb": "11df519acc304a52083bbcdf018bc842510fa9f6621ac957c0e3e994dc6a1843",
+    "libuuid1_2.33.1-0.1_armhf.deb": "31dd55f3044d29370d22f956aa86965b085a201f133771aed5a44631bf989791",
+    "libv4l-0_1.16.3-3_armhf.deb": "b556c9d2765cc20d09a30251b5304cca079ff39bba458ca51b165c426edad096",
+    "libv4lconvert0_1.16.3-3_armhf.deb": "a92e37e6a5447e64506e08ff462359e1428a40685fa66393c159f28df15ca905",
+    "libva-drm2_2.4.0-1_armhf.deb": "2475f97e6e91b6c5afb81ffa0ec00e57727ab44fcbc0eb6947d4ae3dabecd397",
+    "libva-x11-2_2.4.0-1_armhf.deb": "96a84184a734f4795ff0553b1ccb31c29641024b2967327c121f46dc794d9dd1",
+    "libva2_2.4.0-1_armhf.deb": "f4a11116c295ff059b74f2aab5b0156b6e5de493595ede9ccdca21dd2a0b6d24",
+    "libvdpau1_1.1.1-10_armhf.deb": "174cc3df89c9cce18253b832f896dfe4189b765d7122f3dfe8efc48d4b9f2528",
+    "libvisual-0.4-0_0.4.0-15_armhf.deb": "33cf6fff8030c82c5c5ebc78840166a2ce8ad9ab844d113f2fa83dc03d44af7e",
+    "libvorbis0a_1.3.6-2_armhf.deb": "10c7ef81708ea3382fa08dd9185d7f633788362e08e9d5e7549604d6c54bc33c",
+    "libvorbisenc2_1.3.6-2_armhf.deb": "5274a1593ea161d8a4511e4f771eaf83234cc40a383857209d8f38637dee2489",
+    "libvorbisfile3_1.3.6-2_armhf.deb": "22803a4d65a855683ce59f4d95663b786a75a35c2fff78574bdcd70d113318b5",
+    "libvpx5_1.7.0-3+deb10u1_armhf.deb": "44339d7f9ee6a467524aca298a71009092680ff17af4c50b654a0e4ea081f12b",
+    "libvtk6.3_6.3.0+dfsg2-2+b6_armhf.deb": "6f0a4ea94d410d4543fa1f3345b0481960bae5969405c177212c179a177ccf15",
+    "libwavpack1_5.1.0-6_armhf.deb": "d5f7a739bd2ec74e224d205ef2dd331ced7044f687636922c0c3da6250af94a0",
+    "libwayland-client0_1.16.0-1_armhf.deb": "384c3b3288e9a1ecd1014cdb62aece060b47383cb564a001a056bb78f66b2c09",
+    "libwayland-cursor0_1.16.0-1_armhf.deb": "384fd0dbcd9760d62348b5426f3d3072e582a99fd83218ac9d4a91d1758fd40c",
+    "libwayland-egl1_1.16.0-1_armhf.deb": "6270413558873bd434d112e789796d6cba5e0d8703ae19903db0234db2c71924",
+    "libwayland-server0_1.16.0-1_armhf.deb": "9e18a42346475eb28e7b17d1eefb7dddead21fd16226b68f227360fb77ea7bab",
+    "libwebp6_0.6.1-2_armhf.deb": "979fc61f16f7887e4ad602a7df402ed8f12d461fda376fde31de90873920494f",
+    "libwebpmux3_0.6.1-2_armhf.deb": "6237227b67a31609eeaa20c164028447c8db0f07c6aba29da0c0d08d2f758375",
+    "libx11-6_1.6.7-1_armhf.deb": "40450a640133af52c6ca90c150cbb6ff549d3ad0e81c80f8916bc57f6af5d918",
+    "libx11-data_1.6.7-1_all.deb": "eb9e373fa57bf61fe3a3ecb2e869deb639aab5c7a53c90144ce903da255f7431",
+    "libx11-dev_1.6.7-1_armhf.deb": "24dfe78e3adf39ce9c5f95476ef8e8b190071bea85f2d32eb357061a6da19b24",
+    "libx11-xcb1_1.6.7-1_armhf.deb": "13085f3f991abfab2fd17176c0cd97c9ade0856cd864cdb1d560451ee903b967",
+    "libx264-155_0.155.2917+git0a84d98-2+rpi1_armhf.deb": "307de7bd1053117095523c7b4cfa3ca3843490a6f10023beb77c7201143691ab",
+    "libx265-165_2.9-4_armhf.deb": "aeb74dbd170aee841a1908444e6d6997c81da92fc532c41f3908595ea86dd090",
+    "libxau-dev_1.0.8-1+b2_armhf.deb": "0a7803f2807e3912b6cb0641fc77ca142af9721724a4e971bf6c08d3020369ad",
+    "libxau6_1.0.8-1+b2_armhf.deb": "1d1c083edfc29fa3a0c7539565357fcf2f90488dee919444a155afee59ca85eb",
+    "libxcb-dri2-0_1.13.1-2_armhf.deb": "dd81a9718fec85632b80fbac71f2b03972c1c588ed570f4a6c26b7de15ba0914",
+    "libxcb-dri3-0_1.13.1-2_armhf.deb": "7760da9fec785977eea7a1dad02601d7db1841ee36bdba1d05ee8dfd5c65a11a",
+    "libxcb-glx0_1.13.1-2_armhf.deb": "d787c79efcad262895de9fa662cf7646448c1c447b4c8603daa5ac2e49d56aaa",
+    "libxcb-present0_1.13.1-2_armhf.deb": "00d64156b4710ff5621fa95c33a95d608fb59c22cb293dee26c0a09e701b80b2",
+    "libxcb-render0_1.13.1-2_armhf.deb": "842d08da35fd84d9c52d189bb412fc238ada6391da803f4e8a3bc8f9dddeded0",
+    "libxcb-shm0_1.13.1-2_armhf.deb": "d6d35c9e57153832d88a521eb22acb19639e80003de7f3d9c834162fe8e4b5da",
+    "libxcb-sync1_1.13.1-2_armhf.deb": "3a150594eb919886708a37a3c4ad13383ad798780db9175632fd442510fc436b",
+    "libxcb-xfixes0_1.13.1-2_armhf.deb": "11003793d07f6e7383727cb6d45f282d4ce4bc473a3959b4e3fa2ccc9bc60e53",
+    "libxcb1-dev_1.13.1-2_armhf.deb": "04668c3f6bdcf66ab70210ba281603b32a22cfeff8fb8f100d8c1682813915a8",
+    "libxcb1_1.13.1-2_armhf.deb": "9be3930e901f475e377dd0b3fb598d785826699be1e0e4cb1b4c24ed0ad3a46d",
+    "libxcomposite1_0.4.4-2_armhf.deb": "8550a66e62a33368988efbf9c77008e3b030a03a21421a96b595584481b15331",
+    "libxcursor1_1.1.15-2_armhf.deb": "c7ac382c659528b58c053a0c552d5cc9f26aded0caf2e2e3fcd602d978380fe4",
+    "libxdamage1_1.1.4-3+b3_armhf.deb": "51339efb637c4a3bf800ed0e605158e330732cd01c9ff6b8de94f2edc5bc9b29",
+    "libxdmcp-dev_1.1.2-3_armhf.deb": "0b6ec5b04e8118c3d664e7dd7b7efe884a7c116776aa98b89bf6ce648996ea11",
+    "libxdmcp6_1.1.2-3_armhf.deb": "c871d428ca79b15b31967a8e2f19507f06c4af10bcc29429a903a175634af6e4",
+    "libxerces-c3.2_3.2.2+debian-1+b1_armhf.deb": "df1a22c853bf85b6e9afa79751860c57280406d8b40a098ac3bc8f66eceb3255",
+    "libxext6_1.3.3-1+b2_armhf.deb": "4cff4cba6aae865ca4d5e72061d51c16c87985de0232751afce0d05909c755cc",
+    "libxfixes3_5.0.3-1_armhf.deb": "92ee46160bc288442c8e8cd7e0eb2a4dd24e69904333f49371b703af8a9e1b94",
+    "libxft2_2.3.2-2_armhf.deb": "502631a6a91f4a8fccbde895aeedcb518a54e11987f97d20866c325b2eeef220",
+    "libxi6_1.7.9-1_armhf.deb": "f03478e7a8bcf4c144e46d416fb01e74352bddb57a737f3ce78da308784f9639",
+    "libxinerama1_1.1.4-2_armhf.deb": "fb715bf6feefd3695dbaf963191673864a8f73976aa3f52f1197a551af66010e",
+    "libxkbcommon0_0.8.2-1_armhf.deb": "6a45884e50e7e7438e58b6c8387dfeed5f571b79cc8a3e9dc373ffcd6f4a76de",
+    "libxml2_2.9.4+dfsg1-7+b3_armhf.deb": "2629f83a6a430149ed091098e25e22884fb163df01a1f1a3a19765bd205b1a8b",
+    "libxpm4_3.5.12-1_armhf.deb": "f1a677cb3ef3b45e2262e326af71d939ff67dcd0fa3c7a6741706836900612fd",
+    "libxrandr2_1.5.1-1_armhf.deb": "5668f1bf32b9c1d3fe13a90ffb0a15aa5b6445029d24d1718865c08b08581d8a",
+    "libxrender1_0.9.10-1_armhf.deb": "82343e14e073be48577ae1c2c5f95886bc2dddf9a1966b77ba76a827a8e62e44",
+    "libxshmfence1_1.3-1_armhf.deb": "4c9c872c366037d4535e2b5749f34bae782e19171efec6eaaf8c14c9f2486225",
+    "libxss1_1.2.3-1_armhf.deb": "8ce41b86c573c234016450b188551001f7c7da606f090d865adde9c326e1cbc1",
+    "libxt6_1.1.5-1+b3_armhf.deb": "20e1bfa25f403a7014bb3c096a2140b5a6b4db0d370b30774965fc23bb7db122",
+    "libxvidcore4_1.3.5-1_armhf.deb": "caf1801fb13ee60bdc12235f5cd4138a5479b3769be598d29e1864dd7ffd5160",
+    "libxxf86vm1_1.1.4-1+b2_armhf.deb": "cbe30a767f4decb6203bc09661e877579a8adff99ccf73459c698ad0de8efce7",
+    "libzstd1_1.3.8+dfsg-3+rpi1_armhf.deb": "250e609240c682a90b85f2d90024acc63bd0b3f586699929246c1a5d4ba0458c",
+    "libzvbi-common_0.2.35-16_all.deb": "5eea3f86857626ce4371a8a70ba9ce89f1abfc47ed033d1de12ebc0c7d1dd3ea",
+    "libzvbi0_0.2.35-16_armhf.deb": "b8e412ce669fde535a3250714eda0a446c6791771bb6360f93f676efa3d6376d",
+    "lsb-base_10.2019051400+rpi1_all.deb": "b3e203037786d00dd83a5fa9412c8395090921d373e914cb166b395ee2aedaa4",
+    "mariadb-common_10.3.22-0+deb10u1_all.deb": "54fb0fcefe4c0e74e6ad57cea0f47d5b585c2e9597423d8f0205aee8b0982975",
+    "mime-support_3.62_all.deb": "776efd686af26fa26325450280e3305463b1faef75d82b383bb00da61893d8ca",
+    "multiarch-support_2.28-10+rpi1_armhf.deb": "f322ddda60acb6d026fa94e4378e912fbe5e5adb828bb3659b1a6c5e6465f00c",
+    "mysql-common_5.8+1.0.5_all.deb": "340c68aaf03b9c4372467a907575b6a7c980c6d31f90f1d6abc6707a0630608a",
+    "ocl-icd-libopencl1_2.2.12-2_armhf.deb": "634dd778eb0a073609a773b4af463999be6c77b7a757b270ba2759d52e28f16d",
+    "odbcinst1debian2_2.3.6-0.1_armhf.deb": "a2fa334961f985d37602f2eb8ec2a69338897a8e0cba6438b55d365e06624f4c",
+    "odbcinst_2.3.6-0.1_armhf.deb": "81f2678332309805a18b7120dca0c0d76e29ba4e67cca1a629c100893d65a19c",
+    "passwd_4.5-1.1_armhf.deb": "beae91f59bddfe2ca8bf99a70131263d120ada1bdee6d1b3bb46cf96093c44b3",
+    "perl_5.28.1-6_armhf.deb": "464d3c3c46d40e18ebb233106d83a1855931b01b02bd761e72217b161e87ec48",
+    "pkg-config_0.29-6_armhf.deb": "cd1b397b846e4a8b815be6a8e1edbf9a3f509b924030a008c07f2fa3ddd20911",
+    "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_armhf.deb": "8766848b4fec22c1e89a778f29cd5fb6e247c57442a0db65623a85d8be5d25df",
+    "python3.7-minimal_3.7.3-2+deb10u1_armhf.deb": "c467edb5f3d35d94a2c47b9df6ae07e1a1f3d9b7e0022670978417bdba9f597f",
+    "python3.7_3.7.3-2+deb10u1_armhf.deb": "fba9f6b9e93ae7ae037ad6f834651db1a22fd9d74bbdf2be5d61cee25bd32ba8",
+    "python3_3.7.3-1_armhf.deb": "ea96636f2c722bbf9d0cbc3aa3d884ca043fa8196e3e84a490ae867d3750efa4",
+    "raspberrypi-bootloader_1.20200212-1_armhf.deb": "dfcfe58456603f6be487ed49737b54254d235e5c8b99890b3e76fcc07cda3bef",
+    "readline-common_7.0-5_all.deb": "153d8a5ddb04044d10f877a8955d944612ec9035f4c73eec99d85a92c3816712",
+    "sensible-utils_0.0.12_all.deb": "2043859f8bf39a20d075bf52206549f90dcabd66665bb9d6837273494fc6a598",
+    "shared-mime-info_1.10-1_armhf.deb": "9cc1069b361b8c229b4e2afa4c5b7014e0258cca867204f2b9d4735cb7941e68",
+    "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_armhf.deb": "76bd2830e577411840c79cf28560eb8041ddafc1f157d2cb9bde71ed1fbfbb33",
+    "x11-common_7.7+19_all.deb": "221b2e71e0e98b8cafa4fbc674b3fbe293db031c51d35570a3c8cdfb02a5a155",
+    "x11proto-core-dev_2018.4-4_all.deb": "8bdb72e48cac24f5a6b284fea4d2bd6cb11cbe5fba2345ce57d8017ac40243cb",
+    "x11proto-dev_2018.4-4_all.deb": "aa0237467fcb5ccabf6a93fc19fae4d76d8c6dfbf9e449edda5f6393e50d8674",
+    "x11proto-input-dev_2018.4-4_all.deb": "364edce8bb7cf3187c1e81d37ea5b8f6b6ddd3a74c4c82efa1810dd451bbddbf",
+    "x11proto-kb-dev_2018.4-4_all.deb": "14df9b61bf65d8cb8b6053c2bc8f993454e8076d2a5ebc4e8d2bfe671c0592e3",
+    "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_armhf.deb": "c4e5a709233034080b5f8ec7b73c83f26fc8e921326e926aef4a22a6d07415ac",
+    "zlib1g-dev_1.2.11.dfsg-1_armhf.deb": "51561e557bd16f56e1e28b276184f0a6d82617afce987fc8d5322369ab0da478",
+}
diff --git a/frc971/analysis/plot_configs/turret_plot.pb b/frc971/analysis/plot_configs/turret_plot.pb
new file mode 100644
index 0000000..8aee8d7
--- /dev/null
+++ b/frc971/analysis/plot_configs/turret_plot.pb
@@ -0,0 +1,128 @@
+channel {
+  name: "/aos/roborio"
+  type: "aos.JoystickState"
+  alias: "JoystickState"
+}
+channel {
+  name: "/superstructure"
+  type: "y2020.control_loops.superstructure.Status"
+  alias: "Status"
+}
+channel {
+  name: "/superstructure"
+  type: "y2020.control_loops.superstructure.Output"
+  alias: "Output"
+}
+channel {
+  name: "/superstructure"
+  type: "y2020.control_loops.superstructure.Position"
+  alias: "Position"
+}
+channel {
+  name: "/superstructure"
+  type: "y2020.control_loops.superstructure.Goal"
+  alias: "Goal"
+}
+
+figure {
+  axes {
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.goal_velocity"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.unprofiled_goal_velocity"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "aimer.turret_velocity"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.velocity"
+      }
+    }
+  }
+  axes {
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.goal_position"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.unprofiled_goal_position"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "aimer.turret_position"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.position"
+      }
+    }
+  }
+}
+
+figure {
+  axes {
+    line {
+      y_signal {
+        channel: "Status"
+        field: "aimer.aiming_for_inner_port"
+      }
+    }
+#    line {
+#      y_signal {
+#        channel: "JoystickState"
+#        field: "alliance"
+#      }
+#    }
+  }
+  axes {
+    line {
+      y_signal {
+        channel: "Status"
+        field: "aimer.shot_distance"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "aimer.target_distance"
+      }
+    }
+  }
+}
+
+figure {
+  axes {
+    line {
+      y_signal {
+        channel: "Output"
+        field: "turret_voltage"
+      }
+    }
+    line {
+      y_signal {
+        channel: "Status"
+        field: "turret.voltage_error"
+      }
+    }
+  }
+}
diff --git a/frc971/control_loops/drivetrain/BUILD b/frc971/control_loops/drivetrain/BUILD
index d223d13..8c81440 100644
--- a/frc971/control_loops/drivetrain/BUILD
+++ b/frc971/control_loops/drivetrain/BUILD
@@ -1,6 +1,6 @@
 package(default_visibility = ["//visibility:public"])
 
-load("@com_github_google_flatbuffers//:build_defs.bzl", "flatbuffer_cc_library")
+load("@com_github_google_flatbuffers//:build_defs.bzl", "flatbuffer_cc_library", "flatbuffer_ts_library")
 load("//aos:config.bzl", "aos_config")
 load("//tools:environments.bzl", "mcu_cpus")
 load("//tools/build_rules:select.bzl", "compiler_select", "cpu_select")
@@ -35,6 +35,12 @@
     includes = ["//frc971/control_loops:control_loops_fbs_includes"],
 )
 
+flatbuffer_ts_library(
+    name = "drivetrain_status_ts_fbs",
+    srcs = ["drivetrain_status.fbs"],
+    includes = ["//frc971/control_loops:control_loops_fbs_includes"],
+)
+
 genrule(
     name = "drivetrain_goal_float_fbs_generated",
     srcs = ["drivetrain_goal.fbs"],
diff --git a/frc971/control_loops/drivetrain/splinedrivetrain.h b/frc971/control_loops/drivetrain/splinedrivetrain.h
index 051e71a..1ce0e31 100644
--- a/frc971/control_loops/drivetrain/splinedrivetrain.h
+++ b/frc971/control_loops/drivetrain/splinedrivetrain.h
@@ -135,6 +135,7 @@
 
   // TODO(alex): pull this out of dt_config.
   const ::Eigen::DiagonalMatrix<double, 5> Q =
+      0.2 *
       (::Eigen::DiagonalMatrix<double, 5>().diagonal()
            << 1.0 / ::std::pow(0.12, 2),
        1.0 / ::std::pow(0.12, 2), 1.0 / ::std::pow(0.1, 2),
diff --git a/frc971/control_loops/drivetrain/trajectory.cc b/frc971/control_loops/drivetrain/trajectory.cc
index 4da3dee..70ceb1a 100644
--- a/frc971/control_loops/drivetrain/trajectory.cc
+++ b/frc971/control_loops/drivetrain/trajectory.cc
@@ -538,15 +538,11 @@
     // collect more info about when this breaks down from logs.
     K = ::Eigen::Matrix<double, 2, 5>::Zero();
   }
-  ::Eigen::EigenSolver<::Eigen::Matrix<double, 5, 5>> eigensolver(A - B * K);
-  const auto eigenvalues = eigensolver.eigenvalues();
-  AOS_LOG(DEBUG,
-          "Eigenvalues: (%f + %fj), (%f + %fj), (%f + %fj), (%f + %fj), (%f + "
-          "%fj)\n",
-          eigenvalues(0).real(), eigenvalues(0).imag(), eigenvalues(1).real(),
-          eigenvalues(1).imag(), eigenvalues(2).real(), eigenvalues(2).imag(),
-          eigenvalues(3).real(), eigenvalues(3).imag(), eigenvalues(4).real(),
-          eigenvalues(4).imag());
+  if (VLOG_IS_ON(1)) {
+    ::Eigen::EigenSolver<::Eigen::Matrix<double, 5, 5>> eigensolver(A - B * K);
+    const auto eigenvalues = eigensolver.eigenvalues();
+    LOG(INFO) << "Eigenvalues: " << eigenvalues;
+  }
   return K;
 }
 
diff --git a/frc971/control_loops/python/control_loop.py b/frc971/control_loops/python/control_loop.py
index 9c36c90..81f7deb 100644
--- a/frc971/control_loops/python/control_loop.py
+++ b/frc971/control_loops/python/control_loop.py
@@ -5,20 +5,24 @@
 
 class Constant(object):
 
-    def __init__(self, name, formatt, value):
+    def __init__(self, name, formatt, value, comment=None):
         self.name = name
         self.formatt = formatt
         self.value = value
         self.formatToType = {}
         self.formatToType['%f'] = "double"
         self.formatToType['%d'] = "int"
+        if comment is None:
+            self.comment = ""
+        else:
+            self.comment = comment + "\n"
 
     def Render(self, loop_type):
         typestring = self.formatToType[self.formatt]
         if loop_type == 'float' and typestring == 'double':
             typestring = loop_type
-        return str("\nstatic constexpr %s %s = "+ self.formatt +";\n") % \
-            (typestring, self.name, self.value)
+        return str("\n%sstatic constexpr %s %s = "+ self.formatt +";\n") % \
+            (self.comment, typestring, self.name, self.value)
 
 
 class ControlLoopWriter(object):
diff --git a/frc971/control_loops/python/path_edit.py b/frc971/control_loops/python/path_edit.py
index ddc38ac..c186711 100755
--- a/frc971/control_loops/python/path_edit.py
+++ b/frc971/control_loops/python/path_edit.py
@@ -72,6 +72,8 @@
         self.inValue = None
         self.startSet = False
 
+        self.module_path = os.path.dirname(os.path.realpath(sys.argv[0]))
+
     """set extents on images"""
 
     def reinit_extents(self):
@@ -320,35 +322,45 @@
             self.spline_edit = self.points.updates_for_mouse_move(
                 self.index_of_edit, self.spline_edit, self.x, self.y, difs)
 
+    def export_json(self, file_name):
+        self.path_to_export = os.path.join(self.module_path,
+                                           "spline_jsons/" + file_name)
+        if file_name[-5:] != ".json":
+            print("Error: Filename doesn't end in .json")
+        else:
+            # Will export to json file
+            self.mode = Mode.kEditing
+            exportList = [l.tolist() for l in self.points.getSplines()]
+            with open(self.path_to_export, mode='w') as points_file:
+                json.dump(exportList, points_file)
+
+    def import_json(self, file_name):
+        self.path_to_export = os.path.join(self.module_path,
+                                           "spline_jsons/" + file_name)
+        if file_name[-5:] != ".json":
+            print("Error: Filename doesn't end in .json")
+        else:
+            # import from json file
+            self.mode = Mode.kEditing
+            self.points.resetPoints()
+            self.points.resetSplines()
+            print("LOADING LOAD FROM " + file_name) # Load takes a few seconds
+            with open(self.path_to_export) as points_file:
+                self.points.setUpSplines(json.load(points_file))
+
+            self.points.update_lib_spline()
+            print("SPLINES LOADED")
+
     def do_key_press(self, event, file_name):
         keyval = Gdk.keyval_to_lower(event.keyval)
-        module_path = os.path.dirname(os.path.realpath(sys.argv[0]))
-        self.path_to_export = os.path.join(module_path,
-                                           "spline_jsons/" + file_name)
         if keyval == Gdk.KEY_q:
             print("Found q key and exiting.")
             quit_main_loop()
-        file_name_end = file_name[-5:]
-        if file_name_end != ".json":
-            print("Error: Filename doesn't end in .json")
-        else:
-            if keyval == Gdk.KEY_e:
-                # Will export to json file
-                self.mode = Mode.kEditing
-                print('out to: ', self.path_to_export)
-                exportList = [l.tolist() for l in self.points.getSplines()]
-                with open(self.path_to_export, mode='w') as points_file:
-                    json.dump(exportList, points_file)
+        if keyval == Gdk.KEY_e:
+            export_json(file_name)
 
-            if keyval == Gdk.KEY_i:
-                # import from json file
-                self.mode = Mode.kEditing
-                self.points.resetPoints()
-                self.points.resetSplines()
-                with open(self.path_to_export) as points_file:
-                    self.points.setUpSplines(json.load(points_file))
-
-                self.points.update_lib_spline()
+        if keyval == Gdk.KEY_i:
+            import_json(file_name)
 
         if keyval == Gdk.KEY_p:
             self.mode = Mode.kPlacing
diff --git a/frc971/control_loops/python/spline_graph.py b/frc971/control_loops/python/spline_graph.py
index 94ee683..7885ec1 100755
--- a/frc971/control_loops/python/spline_graph.py
+++ b/frc971/control_loops/python/spline_graph.py
@@ -42,10 +42,13 @@
     def configure(self, event):
         self.drawing_area.window_shape = (event.width, event.height)
 
-    # handle submitting a constraint
-    def on_submit_click(self, widget):
-        self.drawing_area.inConstraint = int(self.constraint_box.get_text())
-        self.drawing_area.inValue = int(self.value_box.get_text())
+    def output_json_clicked(self, button):
+        print("OUTPUT JSON CLICKED")
+        self.drawing_area.export_json(self.file_name_box.get_text())
+
+    def input_json_clicked(self, button):
+        print("INPUT JSON CLICKED")
+        self.drawing_area.import_json(self.file_name_box.get_text())
 
     def __init__(self):
         Gtk.Window.__init__(self)
@@ -89,6 +92,17 @@
 
         container.put(self.file_name_box, 0, 0)
 
+        self.output_json = Gtk.Button.new_with_label("Output")
+        self.output_json.set_size_request(100, 40)
+        self.output_json.connect("clicked", self.output_json_clicked)
+
+        self.input_json = Gtk.Button.new_with_label("Import")
+        self.input_json.set_size_request(100, 40)
+        self.input_json.connect("clicked", self.input_json_clicked)
+
+        container.put(self.output_json, 210, 0)
+        container.put(self.input_json, 320, 0)
+
         self.show_all()
 
 
diff --git a/frc971/wpilib/sensor_reader.cc b/frc971/wpilib/sensor_reader.cc
index 0d970e8..2c5e563 100644
--- a/frc971/wpilib/sensor_reader.cc
+++ b/frc971/wpilib/sensor_reader.cc
@@ -118,8 +118,9 @@
   }
 
   if (pwm_trigger_) {
-    AOS_LOG(DEBUG, "PWM wakeup delta: %lld\n",
-            (monotonic_now - last_monotonic_now_).count());
+    // TODO(austin): Put this in a status message.
+    VLOG(1) << "PWM wakeup delta: "
+            << (monotonic_now - last_monotonic_now_).count();
     last_monotonic_now_ = monotonic_now;
 
     monotonic_clock::time_point last_tick_timepoint = GetPWMStartTime();
diff --git a/frc971/zeroing/BUILD b/frc971/zeroing/BUILD
index 75d610a..5955f8b 100644
--- a/frc971/zeroing/BUILD
+++ b/frc971/zeroing/BUILD
@@ -59,9 +59,18 @@
 cc_library(
     name = "zeroing",
     srcs = [
-        "zeroing.cc",
+        "absolute_encoder.cc",
+        "hall_effect_and_position.cc",
+        "pot_and_absolute_encoder.cc",
+        "pot_and_index.cc",
+        "pulse_index.cc",
     ],
     hdrs = [
+        "absolute_encoder.h",
+        "hall_effect_and_position.h",
+        "pot_and_absolute_encoder.h",
+        "pot_and_index.h",
+        "pulse_index.h",
         "zeroing.h",
     ],
     deps = [
@@ -76,11 +85,16 @@
 cc_test(
     name = "zeroing_test",
     srcs = [
-        "zeroing_test.cc",
+        "absolute_encoder_test.cc",
+        "hall_effect_and_position_test.cc",
+        "pot_and_absolute_encoder_test.cc",
+        "pot_and_index_test.cc",
+        "pulse_index_test.cc",
+        "relative_encoder_test.cc",
+        "zeroing_test.h",
     ],
     deps = [
         ":zeroing",
-        "//aos:die",
         "//aos/testing:googletest",
         "//aos/testing:test_shm",
         "//frc971/control_loops:control_loops_fbs",
diff --git a/frc971/zeroing/absolute_encoder.cc b/frc971/zeroing/absolute_encoder.cc
new file mode 100644
index 0000000..ffdf9da
--- /dev/null
+++ b/frc971/zeroing/absolute_encoder.cc
@@ -0,0 +1,178 @@
+#include "frc971/zeroing/absolute_encoder.h"
+
+#include <cmath>
+#include <numeric>
+
+#include "glog/logging.h"
+
+#include "frc971/zeroing/wrap.h"
+
+namespace frc971 {
+namespace zeroing {
+
+AbsoluteEncoderZeroingEstimator::AbsoluteEncoderZeroingEstimator(
+    const constants::AbsoluteEncoderZeroingConstants &constants)
+    : constants_(constants), move_detector_(constants_.moving_buffer_size) {
+  relative_to_absolute_offset_samples_.reserve(constants_.average_filter_size);
+  Reset();
+}
+
+void AbsoluteEncoderZeroingEstimator::Reset() {
+  zeroed_ = false;
+  error_ = false;
+  first_offset_ = 0.0;
+  offset_ = 0.0;
+  samples_idx_ = 0;
+  position_ = 0.0;
+  nan_samples_ = 0;
+  relative_to_absolute_offset_samples_.clear();
+  move_detector_.Reset();
+}
+
+
+// The math here is a bit backwards, but I think it'll be less error prone that
+// way and more similar to the version with a pot as well.
+//
+// We start by unwrapping the absolute encoder using the relative encoder.  This
+// puts us in a non-wrapping space and lets us average a bit easier.  From
+// there, we can compute an offset and wrap ourselves back such that we stay
+// close to the middle value.
+//
+// To guard against the robot moving while updating estimates, buffer a number
+// of samples and check that the buffered samples are not different than the
+// zeroing threshold. At any point that the samples differ too much, do not
+// update estimates based on those samples.
+void AbsoluteEncoderZeroingEstimator::UpdateEstimate(
+    const AbsolutePosition &info) {
+  // Check for Abs Encoder NaN value that would mess up the rest of the zeroing
+  // code below. NaN values are given when the Absolute Encoder is disconnected.
+  if (::std::isnan(info.absolute_encoder())) {
+    if (zeroed_) {
+      VLOG(1) << "NAN on absolute encoder.";
+      error_ = true;
+    } else {
+      ++nan_samples_;
+      VLOG(1) << "NAN on absolute encoder while zeroing " << nan_samples_;
+      if (nan_samples_ >= constants_.average_filter_size) {
+        error_ = true;
+        zeroed_ = true;
+      }
+    }
+    // Throw some dummy values in for now.
+    filtered_absolute_encoder_ = info.absolute_encoder();
+    position_ = offset_ + info.encoder();
+    return;
+  }
+
+  const bool moving = move_detector_.Update(info, constants_.moving_buffer_size,
+                                            constants_.zeroing_threshold);
+
+  if (!moving) {
+    const PositionStruct &sample = move_detector_.GetSample();
+
+    // Compute the average offset between the absolute encoder and relative
+    // encoder.  If we have 0 samples, assume it is 0.
+    double average_relative_to_absolute_offset =
+        relative_to_absolute_offset_samples_.size() == 0
+            ? 0.0
+            : ::std::accumulate(relative_to_absolute_offset_samples_.begin(),
+                                relative_to_absolute_offset_samples_.end(),
+                                0.0) /
+                  relative_to_absolute_offset_samples_.size();
+
+    // Now, compute the estimated absolute position using the previously
+    // estimated offset and the incremental encoder.
+    const double adjusted_incremental_encoder =
+        sample.encoder + average_relative_to_absolute_offset;
+
+    // Now, compute the absolute encoder value nearest to the offset relative
+    // encoder position.
+    const double adjusted_absolute_encoder =
+        UnWrap(adjusted_incremental_encoder,
+               sample.absolute_encoder - constants_.measured_absolute_position,
+               constants_.one_revolution_distance);
+
+    // We can now compute the offset now that we have unwrapped the absolute
+    // encoder.
+    const double relative_to_absolute_offset =
+        adjusted_absolute_encoder - sample.encoder;
+
+    // Add the sample and update the average with the new reading.
+    const size_t relative_to_absolute_offset_samples_size =
+        relative_to_absolute_offset_samples_.size();
+    if (relative_to_absolute_offset_samples_size <
+        constants_.average_filter_size) {
+      average_relative_to_absolute_offset =
+          (average_relative_to_absolute_offset *
+               relative_to_absolute_offset_samples_size +
+           relative_to_absolute_offset) /
+          (relative_to_absolute_offset_samples_size + 1);
+
+      relative_to_absolute_offset_samples_.push_back(
+          relative_to_absolute_offset);
+    } else {
+      average_relative_to_absolute_offset -=
+          relative_to_absolute_offset_samples_[samples_idx_] /
+          relative_to_absolute_offset_samples_size;
+      relative_to_absolute_offset_samples_[samples_idx_] =
+          relative_to_absolute_offset;
+      average_relative_to_absolute_offset +=
+          relative_to_absolute_offset /
+          relative_to_absolute_offset_samples_size;
+    }
+
+    // Drop the oldest sample when we run this function the next time around.
+    samples_idx_ = (samples_idx_ + 1) % constants_.average_filter_size;
+
+    // And our offset is the offset that gives us the position within +- ord/2
+    // of the middle position.
+    offset_ = Wrap(constants_.middle_position,
+                   average_relative_to_absolute_offset + sample.encoder,
+                   constants_.one_revolution_distance) -
+              sample.encoder;
+
+    // Reverse the math for adjusted_absolute_encoder to compute the absolute
+    // encoder. Do this by taking the adjusted encoder, and then subtracting off
+    // the second argument above, and the value that was added by Wrap.
+    filtered_absolute_encoder_ =
+        ((sample.encoder + average_relative_to_absolute_offset) -
+         (-constants_.measured_absolute_position +
+          (adjusted_absolute_encoder -
+           (sample.absolute_encoder - constants_.measured_absolute_position))));
+
+    if (offset_ready()) {
+      if (!zeroed_) {
+        first_offset_ = offset_;
+      }
+
+      if (::std::abs(first_offset_ - offset_) >
+          constants_.allowable_encoder_error *
+              constants_.one_revolution_distance) {
+        VLOG(1) << "Offset moved too far. Initial: " << first_offset_
+                << ", current " << offset_ << ", allowable change: "
+                << constants_.allowable_encoder_error *
+                       constants_.one_revolution_distance;
+        error_ = true;
+      }
+
+      zeroed_ = true;
+    }
+  }
+
+  // Update the position.
+  position_ = offset_ + info.encoder();
+}
+
+flatbuffers::Offset<AbsoluteEncoderZeroingEstimator::State>
+AbsoluteEncoderZeroingEstimator::GetEstimatorState(
+    flatbuffers::FlatBufferBuilder *fbb) const {
+  State::Builder builder(*fbb);
+  builder.add_error(error_);
+  builder.add_zeroed(zeroed_);
+  builder.add_position(position_);
+  builder.add_absolute_position(filtered_absolute_encoder_);
+  return builder.Finish();
+}
+
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/absolute_encoder.h b/frc971/zeroing/absolute_encoder.h
new file mode 100644
index 0000000..0021e13
--- /dev/null
+++ b/frc971/zeroing/absolute_encoder.h
@@ -0,0 +1,93 @@
+#ifndef FRC971_ZEROING_ABSOLUTE_ENCODER_H_
+#define FRC971_ZEROING_ABSOLUTE_ENCODER_H_
+
+#include <vector>
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "frc971/zeroing/zeroing.h"
+
+namespace frc971 {
+namespace zeroing {
+
+// Estimates the position with an absolute encoder which also reports
+// incremental counts.  The absolute encoder can't spin more than one
+// revolution.
+class AbsoluteEncoderZeroingEstimator
+    : public ZeroingEstimator<AbsolutePosition,
+                              constants::AbsoluteEncoderZeroingConstants,
+                              AbsoluteEncoderEstimatorState> {
+ public:
+  explicit AbsoluteEncoderZeroingEstimator(
+      const constants::AbsoluteEncoderZeroingConstants &constants);
+
+  // Resets the internal logic so it needs to be re-zeroed.
+  void Reset() override;
+
+  // Updates the sensor values for the zeroing logic.
+  void UpdateEstimate(const AbsolutePosition &info) override;
+
+  void TriggerError() override { error_ = true; }
+
+  bool zeroed() const override { return zeroed_; }
+
+  double offset() const override { return offset_; }
+
+  bool error() const override { return error_; }
+
+  // Returns true if the sample buffer is full.
+  bool offset_ready() const override {
+    return relative_to_absolute_offset_samples_.size() ==
+           constants_.average_filter_size;
+  }
+
+  // Returns information about our current state.
+  virtual flatbuffers::Offset<State> GetEstimatorState(
+      flatbuffers::FlatBufferBuilder *fbb) const override;
+
+ private:
+  struct PositionStruct {
+    PositionStruct(const AbsolutePosition &position_buffer)
+        : absolute_encoder(position_buffer.absolute_encoder()),
+          encoder(position_buffer.encoder()) {}
+    double absolute_encoder;
+    double encoder;
+  };
+
+  // The zeroing constants used to describe the configuration of the system.
+  const constants::AbsoluteEncoderZeroingConstants constants_;
+
+  // True if the mechanism is zeroed.
+  bool zeroed_;
+  // Marker to track whether an error has occurred.
+  bool error_;
+  // The first valid offset we recorded. This is only set after zeroed_ first
+  // changes to true.
+  double first_offset_;
+
+  // The filtered absolute encoder.  This is used in the status for calibration.
+  double filtered_absolute_encoder_ = 0.0;
+
+  // Samples of the offset needed to line the relative encoder up with the
+  // absolute encoder.
+  ::std::vector<double> relative_to_absolute_offset_samples_;
+
+  MoveDetector<PositionStruct, AbsolutePosition> move_detector_;
+
+  // Estimated start position of the mechanism
+  double offset_ = 0;
+  // The next position in 'relative_to_absolute_offset_samples_' and
+  // 'encoder_samples_' to be used to store the next sample.
+  int samples_idx_ = 0;
+
+  // Number of NANs we've seen in a row.
+  size_t nan_samples_ = 0;
+
+  // The filtered position.
+  double position_ = 0.0;
+};
+
+}  // namespace zeroing
+}  // namespace frc971
+
+#endif  // FRC971_ZEROING_ABSOLUTE_ENCODER_H_
diff --git a/frc971/zeroing/absolute_encoder_test.cc b/frc971/zeroing/absolute_encoder_test.cc
new file mode 100644
index 0000000..38ce069
--- /dev/null
+++ b/frc971/zeroing/absolute_encoder_test.cc
@@ -0,0 +1,145 @@
+#include "frc971/zeroing/absolute_encoder.h"
+
+#include "gtest/gtest.h"
+
+#include "frc971/zeroing/zeroing_test.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+using constants::AbsoluteEncoderZeroingConstants;
+
+class AbsoluteEncoderZeroingTest : public ZeroingTest {
+ protected:
+  void MoveTo(PositionSensorSimulator *simulator,
+              AbsoluteEncoderZeroingEstimator *estimator, double new_position) {
+    simulator->MoveTo(new_position);
+    FBB fbb;
+    estimator->UpdateEstimate(
+        *simulator->FillSensorValues<AbsolutePosition>(&fbb));
+  }
+};
+
+// Makes sure that using an absolute encoder lets us zero without moving.
+TEST_F(AbsoluteEncoderZeroingTest, TestAbsoluteEncoderZeroingWithoutMovement) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+
+  const double kMiddlePosition = 2.5;
+  const double start_pos = 2.1;
+  double measured_absolute_position = 0.3 * index_diff;
+
+  AbsoluteEncoderZeroingConstants constants{
+      kSampleSize,        index_diff, measured_absolute_position,
+      kMiddlePosition,    0.1,        kMovingBufferSize,
+      kIndexErrorFraction};
+
+  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
+                 constants.measured_absolute_position);
+
+  AbsoluteEncoderZeroingEstimator estimator(constants);
+
+  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
+    MoveTo(&sim, &estimator, start_pos);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  MoveTo(&sim, &estimator, start_pos);
+  ASSERT_TRUE(estimator.zeroed());
+  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
+}
+
+// Makes sure that we ignore a NAN if we get it, but will correctly zero
+// afterwards.
+TEST_F(AbsoluteEncoderZeroingTest, TestAbsoluteEncoderZeroingIgnoresNAN) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+
+  const double start_pos = 2.1;
+  double measured_absolute_position = 0.3 * index_diff;
+  const double kMiddlePosition = 2.5;
+
+  AbsoluteEncoderZeroingConstants constants{
+      kSampleSize,        index_diff, measured_absolute_position,
+      kMiddlePosition,    0.1,        kMovingBufferSize,
+      kIndexErrorFraction};
+
+  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
+                 constants.measured_absolute_position);
+
+  AbsoluteEncoderZeroingEstimator estimator(constants);
+
+  // We tolerate a couple NANs before we start.
+  FBB fbb;
+  fbb.Finish(CreateAbsolutePosition(
+      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN()));
+  const auto sensor_values =
+      flatbuffers::GetRoot<AbsolutePosition>(fbb.GetBufferPointer());
+  for (size_t i = 0; i < kSampleSize - 1; ++i) {
+    estimator.UpdateEstimate(*sensor_values);
+  }
+
+  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
+    MoveTo(&sim, &estimator, start_pos);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  MoveTo(&sim, &estimator, start_pos);
+  ASSERT_TRUE(estimator.zeroed());
+  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
+}
+
+// Makes sure that using an absolute encoder doesn't let us zero while moving.
+TEST_F(AbsoluteEncoderZeroingTest, TestAbsoluteEncoderZeroingWithMovement) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+
+  const double start_pos = 10 * index_diff;
+  double measured_absolute_position = 0.3 * index_diff;
+  const double kMiddlePosition = 2.5;
+
+  AbsoluteEncoderZeroingConstants constants{
+      kSampleSize,        index_diff, measured_absolute_position,
+      kMiddlePosition,    0.1,        kMovingBufferSize,
+      kIndexErrorFraction};
+
+  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
+                 constants.measured_absolute_position);
+
+  AbsoluteEncoderZeroingEstimator estimator(constants);
+
+  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
+    MoveTo(&sim, &estimator, start_pos + i * index_diff);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+  MoveTo(&sim, &estimator, start_pos + 10 * index_diff);
+
+  MoveTo(&sim, &estimator, start_pos);
+  ASSERT_FALSE(estimator.zeroed());
+}
+
+// Makes sure we detect an error if the ZeroingEstimator gets sent a NaN.
+TEST_F(AbsoluteEncoderZeroingTest, TestAbsoluteEncoderZeroingWithNaN) {
+  AbsoluteEncoderZeroingConstants constants{
+      kSampleSize, 1, 0.3, 1.0, 0.1, kMovingBufferSize, kIndexErrorFraction};
+
+  AbsoluteEncoderZeroingEstimator estimator(constants);
+
+  FBB fbb;
+  fbb.Finish(CreateAbsolutePosition(
+      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN()));
+  const auto sensor_values =
+      flatbuffers::GetRoot<AbsolutePosition>(fbb.GetBufferPointer());
+  for (size_t i = 0; i < kSampleSize - 1; ++i) {
+    estimator.UpdateEstimate(*sensor_values);
+  }
+  ASSERT_FALSE(estimator.error());
+
+  estimator.UpdateEstimate(*sensor_values);
+  ASSERT_TRUE(estimator.error());
+}
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/hall_effect_and_position.cc b/frc971/zeroing/hall_effect_and_position.cc
new file mode 100644
index 0000000..e074668
--- /dev/null
+++ b/frc971/zeroing/hall_effect_and_position.cc
@@ -0,0 +1,127 @@
+#include "frc971/zeroing/hall_effect_and_position.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include "glog/logging.h"
+
+namespace frc971 {
+namespace zeroing {
+
+HallEffectAndPositionZeroingEstimator::HallEffectAndPositionZeroingEstimator(
+    const ZeroingConstants &constants)
+    : constants_(constants) {
+  Reset();
+}
+
+void HallEffectAndPositionZeroingEstimator::Reset() {
+  offset_ = 0.0;
+  min_low_position_ = ::std::numeric_limits<double>::max();
+  max_low_position_ = ::std::numeric_limits<double>::lowest();
+  zeroed_ = false;
+  initialized_ = false;
+  last_used_posedge_count_ = 0;
+  cycles_high_ = 0;
+  high_long_enough_ = false;
+  first_start_pos_ = 0.0;
+  error_ = false;
+  current_ = 0.0;
+  first_start_pos_ = 0.0;
+}
+
+void HallEffectAndPositionZeroingEstimator::TriggerError() {
+  if (!error_) {
+    VLOG(1) << "Manually triggered zeroing error.\n";
+    error_ = true;
+  }
+}
+
+void HallEffectAndPositionZeroingEstimator::StoreEncoderMaxAndMin(
+    const HallEffectAndPosition &info) {
+  // If we have a new posedge.
+  if (!info.current()) {
+    if (last_hall_) {
+      min_low_position_ = max_low_position_ = info.encoder();
+    } else {
+      min_low_position_ = ::std::min(min_low_position_, info.encoder());
+      max_low_position_ = ::std::max(max_low_position_, info.encoder());
+    }
+  }
+  last_hall_ = info.current();
+}
+
+void HallEffectAndPositionZeroingEstimator::UpdateEstimate(
+    const HallEffectAndPosition &info) {
+  // We want to make sure that we encounter at least one posedge while zeroing.
+  // So we take the posedge count from the first sample after reset and wait for
+  // that count to change and for the hall effect to stay high before we
+  // consider ourselves zeroed.
+  if (!initialized_) {
+    last_used_posedge_count_ = info.posedge_count();
+    initialized_ = true;
+    last_hall_ = info.current();
+  }
+
+  StoreEncoderMaxAndMin(info);
+
+  if (info.current()) {
+    cycles_high_++;
+  } else {
+    cycles_high_ = 0;
+    last_used_posedge_count_ = info.posedge_count();
+  }
+
+  high_long_enough_ = cycles_high_ >= constants_.hall_trigger_zeroing_length;
+
+  bool moving_backward = false;
+  if (constants_.zeroing_move_direction) {
+    moving_backward = info.encoder() > min_low_position_;
+  } else {
+    moving_backward = info.encoder() < max_low_position_;
+  }
+
+  // If there are no posedges to use or we don't have enough samples yet to
+  // have a well-filtered starting position then we use the filtered value as
+  // our best guess.
+  if (last_used_posedge_count_ != info.posedge_count() && high_long_enough_ &&
+      moving_backward) {
+    // Note the offset and the current posedge count so that we only run this
+    // logic once per posedge. That should be more resilient to corrupted
+    // intermediate data.
+    offset_ = -info.posedge_value();
+    if (constants_.zeroing_move_direction) {
+      offset_ += constants_.lower_hall_position;
+    } else {
+      offset_ += constants_.upper_hall_position;
+    }
+    last_used_posedge_count_ = info.posedge_count();
+
+    // Save the first starting position.
+    if (!zeroed_) {
+      first_start_pos_ = offset_;
+      VLOG(2) << "latching start position" << first_start_pos_;
+    }
+
+    // Now that we have an accurate starting position we can consider ourselves
+    // zeroed.
+    zeroed_ = true;
+  }
+
+  position_ = info.encoder() - offset_;
+}
+
+flatbuffers::Offset<HallEffectAndPositionZeroingEstimator::State>
+HallEffectAndPositionZeroingEstimator::GetEstimatorState(
+    flatbuffers::FlatBufferBuilder *fbb) const {
+  State::Builder builder(*fbb);
+  builder.add_error(error_);
+  builder.add_zeroed(zeroed_);
+  builder.add_encoder(position_);
+  builder.add_high_long_enough(high_long_enough_);
+  builder.add_offset(offset_);
+  return builder.Finish();
+}
+
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/hall_effect_and_position.h b/frc971/zeroing/hall_effect_and_position.h
new file mode 100644
index 0000000..f03a442
--- /dev/null
+++ b/frc971/zeroing/hall_effect_and_position.h
@@ -0,0 +1,90 @@
+#ifndef FRC971_ZEROING_HALL_EFFECT_AND_POSITION_H_
+#define FRC971_ZEROING_HALL_EFFECT_AND_POSITION_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "frc971/zeroing/zeroing.h"
+
+namespace frc971 {
+namespace zeroing {
+
+// Estimates the position with an incremental encoder and a hall effect sensor.
+class HallEffectAndPositionZeroingEstimator
+    : public ZeroingEstimator<HallEffectAndPosition,
+                              constants::HallEffectZeroingConstants,
+                              HallEffectAndPositionEstimatorState> {
+ public:
+  explicit HallEffectAndPositionZeroingEstimator(
+      const ZeroingConstants &constants);
+
+  // Update the internal logic with the next sensor values.
+  void UpdateEstimate(const Position &info) override;
+
+  // Reset the internal logic so it needs to be re-zeroed.
+  void Reset() override;
+
+  // Manually trigger an internal error. This is used for testing the error
+  // logic.
+  void TriggerError() override;
+
+  bool error() const override { return error_; }
+
+  bool zeroed() const override { return zeroed_; }
+
+  double offset() const override { return offset_; }
+
+  bool offset_ready() const override { return zeroed_; }
+
+  // Returns information about our current state.
+  virtual flatbuffers::Offset<State> GetEstimatorState(
+      flatbuffers::FlatBufferBuilder *fbb) const override;
+
+ private:
+  // Sets the minimum and maximum posedge position values.
+  void StoreEncoderMaxAndMin(const HallEffectAndPosition &info);
+
+  // The zeroing constants used to describe the configuration of the system.
+  const ZeroingConstants constants_;
+
+  // The estimated state of the hall effect.
+  double current_ = 0.0;
+  // The estimated position.
+  double position_ = 0.0;
+  // The smallest and largest positions of the last set of encoder positions
+  // while the hall effect was low.
+  double min_low_position_;
+  double max_low_position_;
+  // If we've seen the hall effect high for enough times without going low, then
+  // we can be sure it isn't a false positive.
+  bool high_long_enough_;
+  size_t cycles_high_;
+
+  bool last_hall_ = false;
+
+  // The estimated starting position of the mechanism. We also call this the
+  // 'offset' in some contexts.
+  double offset_;
+  // Flag for triggering logic that takes note of the current posedge count
+  // after a reset. See `last_used_posedge_count_'.
+  bool initialized_;
+  // After a reset we keep track of the posedge count with this. Only after the
+  // posedge count changes (i.e. increments at least once or wraps around) will
+  // we consider the mechanism zeroed. We also use this to store the most recent
+  // `HallEffectAndPosition::posedge_count' value when the start position
+  // was calculated. It helps us calculate the start position only on posedges
+  // to reject corrupted intermediate data.
+  int32_t last_used_posedge_count_;
+  // Marker to track whether we're fully zeroed yet or not.
+  bool zeroed_;
+  // Marker to track whether an error has occurred. This gets reset to false
+  // whenever Reset() is called.
+  bool error_ = false;
+  // Stores the position "start_pos" variable the first time the program
+  // is zeroed.
+  double first_start_pos_;
+};
+
+}  // namespace zeroing
+}  // namespace frc971
+
+#endif  // FRC971_ZEROING_HALL_EFFECT_AND_POSITION_H_
diff --git a/frc971/zeroing/hall_effect_and_position_test.cc b/frc971/zeroing/hall_effect_and_position_test.cc
new file mode 100644
index 0000000..c9ddf65
--- /dev/null
+++ b/frc971/zeroing/hall_effect_and_position_test.cc
@@ -0,0 +1,135 @@
+#include "frc971/zeroing/hall_effect_and_position.h"
+
+#include "gtest/gtest.h"
+
+#include "frc971/zeroing/zeroing_test.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+class HallEffectAndPositionZeroingTest : public ZeroingTest {
+ protected:
+  // The starting position of the system.
+  static constexpr double kStartPosition = 2.0;
+
+  HallEffectAndPositionZeroingTest()
+      : constants_(MakeConstants()), sim_(constants_.index_difference) {
+    // Start the system out at the starting position.
+    sim_.InitializeHallEffectAndPosition(kStartPosition,
+                                         constants_.lower_hall_position,
+                                         constants_.upper_hall_position);
+  }
+
+  void MoveTo(PositionSensorSimulator *simulator,
+              HallEffectAndPositionZeroingEstimator *estimator,
+              double new_position) {
+    simulator->MoveTo(new_position);
+    FBB fbb;
+    estimator->UpdateEstimate(
+        *simulator->FillSensorValues<HallEffectAndPosition>(&fbb));
+  }
+
+  // Returns a reasonable set of test constants.
+  static constants::HallEffectZeroingConstants MakeConstants() {
+    constants::HallEffectZeroingConstants constants;
+    constants.lower_hall_position = 0.25;
+    constants.upper_hall_position = 0.75;
+    constants.index_difference = 1.0;
+    constants.hall_trigger_zeroing_length = 2;
+    constants.zeroing_move_direction = false;
+    return constants;
+  }
+
+  // Constants, and the simulation using them.
+  const constants::HallEffectZeroingConstants constants_;
+  PositionSensorSimulator sim_;
+};
+
+// Tests that an error is detected when the starting position changes too much.
+TEST_F(HallEffectAndPositionZeroingTest, TestHallEffectZeroing) {
+  HallEffectAndPositionZeroingEstimator estimator(constants_);
+
+  // Should not be zeroed when we stand still.
+  for (int i = 0; i < 300; ++i) {
+    MoveTo(&sim_, &estimator, kStartPosition);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  MoveTo(&sim_, &estimator, 1.9);
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Move to where the hall effect is triggered and make sure it becomes zeroed.
+  MoveTo(&sim_, &estimator, 1.5);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 1.5);
+  ASSERT_TRUE(estimator.zeroed());
+
+  // Check that the offset is calculated correctly.  We should expect to read
+  // 0.5.  Since the encoder is reading -0.5 right now, the offset needs to be
+  // 1.
+  EXPECT_DOUBLE_EQ(1.0, estimator.offset());
+
+  // Make sure triggering errors works.
+  estimator.TriggerError();
+  ASSERT_TRUE(estimator.error());
+
+  // Ensure resetting resets the state of the estimator.
+  estimator.Reset();
+  ASSERT_FALSE(estimator.zeroed());
+  ASSERT_FALSE(estimator.error());
+}
+
+// Tests that we don't zero on a too short pulse.
+TEST_F(HallEffectAndPositionZeroingTest, TestTooShortPulse) {
+  HallEffectAndPositionZeroingEstimator estimator(constants_);
+
+  // Trigger for 1 cycle.
+  MoveTo(&sim_, &estimator, 0.9);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.5);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.9);
+  EXPECT_FALSE(estimator.zeroed());
+}
+
+// Tests that we don't zero when we go the wrong direction.
+TEST_F(HallEffectAndPositionZeroingTest, TestWrongDirectionNoZero) {
+  HallEffectAndPositionZeroingEstimator estimator(constants_);
+
+  // Pass through the sensor, lingering long enough that we should zero.
+  MoveTo(&sim_, &estimator, 0.0);
+  ASSERT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.4);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.6);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.7);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.9);
+  EXPECT_FALSE(estimator.zeroed());
+}
+
+// Make sure we don't zero if we start in the hall effect's range.
+TEST_F(HallEffectAndPositionZeroingTest, TestStartingOnNoZero) {
+  HallEffectAndPositionZeroingEstimator estimator(constants_);
+  MoveTo(&sim_, &estimator, 0.5);
+  estimator.Reset();
+
+  // Stay on the hall effect.  We shouldn't zero.
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.5);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.5);
+  EXPECT_FALSE(estimator.zeroed());
+
+  // Verify moving off the hall still doesn't zero us.
+  MoveTo(&sim_, &estimator, 0.0);
+  EXPECT_FALSE(estimator.zeroed());
+  MoveTo(&sim_, &estimator, 0.0);
+  EXPECT_FALSE(estimator.zeroed());
+}
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/pot_and_absolute_encoder.cc b/frc971/zeroing/pot_and_absolute_encoder.cc
new file mode 100644
index 0000000..200f399
--- /dev/null
+++ b/frc971/zeroing/pot_and_absolute_encoder.cc
@@ -0,0 +1,196 @@
+#include "frc971/zeroing/pot_and_absolute_encoder.h"
+
+#include <cmath>
+#include <numeric>
+
+#include "glog/logging.h"
+
+#include "frc971/zeroing/wrap.h"
+
+namespace frc971 {
+namespace zeroing {
+
+PotAndAbsoluteEncoderZeroingEstimator::PotAndAbsoluteEncoderZeroingEstimator(
+    const constants::PotAndAbsoluteEncoderZeroingConstants &constants)
+    : constants_(constants), move_detector_(constants_.moving_buffer_size) {
+  relative_to_absolute_offset_samples_.reserve(constants_.average_filter_size);
+  offset_samples_.reserve(constants_.average_filter_size);
+  Reset();
+}
+
+void PotAndAbsoluteEncoderZeroingEstimator::Reset() {
+  first_offset_ = 0.0;
+  pot_relative_encoder_offset_ = 0.0;
+  offset_ = 0.0;
+  samples_idx_ = 0;
+  filtered_position_ = 0.0;
+  position_ = 0.0;
+  zeroed_ = false;
+  nan_samples_ = 0;
+  relative_to_absolute_offset_samples_.clear();
+  offset_samples_.clear();
+  move_detector_.Reset();
+  error_ = false;
+}
+
+// So, this needs to be a multistep process.  We need to first estimate the
+// offset between the absolute encoder and the relative encoder.  That process
+// should get us an absolute number which is off by integer multiples of the
+// distance/rev.  In parallel, we can estimate the offset between the pot and
+// encoder.  When both estimates have converged, we can then compute the offset
+// in a cycle, and which cycle, which gives us the accurate global offset.
+//
+// It's tricky to compute the offset between the absolute and relative encoder.
+// We need to compute this inside 1 revolution.  The easiest way to do this
+// would be to wrap the encoder, subtract the two of them, and then average the
+// result.  That will struggle when they are off by PI.  Instead, we need to
+// wrap the number to +- PI from the current averaged offset.
+//
+// To guard against the robot moving while updating estimates, buffer a number
+// of samples and check that the buffered samples are not different than the
+// zeroing threshold. At any point that the samples differ too much, do not
+// update estimates based on those samples.
+void PotAndAbsoluteEncoderZeroingEstimator::UpdateEstimate(
+    const PotAndAbsolutePosition &info) {
+  // Check for Abs Encoder NaN value that would mess up the rest of the zeroing
+  // code below. NaN values are given when the Absolute Encoder is disconnected.
+  if (::std::isnan(info.absolute_encoder())) {
+    if (zeroed_) {
+      VLOG(1) << "NAN on absolute encoder.";
+      error_ = true;
+    } else {
+      ++nan_samples_;
+      VLOG(1) << "NAN on absolute encoder while zeroing" << nan_samples_;
+      if (nan_samples_ >= constants_.average_filter_size) {
+        error_ = true;
+        zeroed_ = true;
+      }
+    }
+    // Throw some dummy values in for now.
+    filtered_absolute_encoder_ = info.absolute_encoder();
+    filtered_position_ = pot_relative_encoder_offset_ + info.encoder();
+    position_ = offset_ + info.encoder();
+    return;
+  }
+
+  const bool moving = move_detector_.Update(info, constants_.moving_buffer_size,
+                                            constants_.zeroing_threshold);
+
+  if (!moving) {
+    const PositionStruct &sample = move_detector_.GetSample();
+
+    // Compute the average offset between the absolute encoder and relative
+    // encoder.  If we have 0 samples, assume it is 0.
+    double average_relative_to_absolute_offset =
+        relative_to_absolute_offset_samples_.size() == 0
+            ? 0.0
+            : ::std::accumulate(relative_to_absolute_offset_samples_.begin(),
+                                relative_to_absolute_offset_samples_.end(),
+                                0.0) /
+                  relative_to_absolute_offset_samples_.size();
+
+    const double adjusted_incremental_encoder =
+        sample.encoder + average_relative_to_absolute_offset;
+
+    // Now, compute the nearest absolute encoder value to the offset relative
+    // encoder position.
+    const double adjusted_absolute_encoder =
+        UnWrap(adjusted_incremental_encoder,
+               sample.absolute_encoder - constants_.measured_absolute_position,
+               constants_.one_revolution_distance);
+
+    // We can now compute the offset now that we have unwrapped the absolute
+    // encoder.
+    const double relative_to_absolute_offset =
+        adjusted_absolute_encoder - sample.encoder;
+
+    // Add the sample and update the average with the new reading.
+    const size_t relative_to_absolute_offset_samples_size =
+        relative_to_absolute_offset_samples_.size();
+    if (relative_to_absolute_offset_samples_size <
+        constants_.average_filter_size) {
+      average_relative_to_absolute_offset =
+          (average_relative_to_absolute_offset *
+               relative_to_absolute_offset_samples_size +
+           relative_to_absolute_offset) /
+          (relative_to_absolute_offset_samples_size + 1);
+
+      relative_to_absolute_offset_samples_.push_back(
+          relative_to_absolute_offset);
+    } else {
+      average_relative_to_absolute_offset -=
+          relative_to_absolute_offset_samples_[samples_idx_] /
+          relative_to_absolute_offset_samples_size;
+      relative_to_absolute_offset_samples_[samples_idx_] =
+          relative_to_absolute_offset;
+      average_relative_to_absolute_offset +=
+          relative_to_absolute_offset /
+          relative_to_absolute_offset_samples_size;
+    }
+
+    // Now compute the offset between the pot and relative encoder.
+    if (offset_samples_.size() < constants_.average_filter_size) {
+      offset_samples_.push_back(sample.pot - sample.encoder);
+    } else {
+      offset_samples_[samples_idx_] = sample.pot - sample.encoder;
+    }
+
+    // Drop the oldest sample when we run this function the next time around.
+    samples_idx_ = (samples_idx_ + 1) % constants_.average_filter_size;
+
+    pot_relative_encoder_offset_ =
+        ::std::accumulate(offset_samples_.begin(), offset_samples_.end(), 0.0) /
+        offset_samples_.size();
+
+    offset_ = UnWrap(sample.encoder + pot_relative_encoder_offset_,
+                     average_relative_to_absolute_offset + sample.encoder,
+                     constants_.one_revolution_distance) -
+              sample.encoder;
+
+    // Reverse the math for adjusted_absolute_encoder to compute the absolute
+    // encoder. Do this by taking the adjusted encoder, and then subtracting off
+    // the second argument above, and the value that was added by Wrap.
+    filtered_absolute_encoder_ =
+        ((sample.encoder + average_relative_to_absolute_offset) -
+         (-constants_.measured_absolute_position +
+          (adjusted_absolute_encoder -
+           (sample.absolute_encoder - constants_.measured_absolute_position))));
+
+    if (offset_ready()) {
+      if (!zeroed_) {
+        first_offset_ = offset_;
+      }
+
+      if (::std::abs(first_offset_ - offset_) >
+          constants_.allowable_encoder_error *
+              constants_.one_revolution_distance) {
+        VLOG(1) << "Offset moved too far. Initial: " << first_offset_
+                << ", current " << offset_ << ", allowable change: "
+                << constants_.allowable_encoder_error *
+                       constants_.one_revolution_distance;
+        error_ = true;
+      }
+
+      zeroed_ = true;
+    }
+  }
+
+  // Update the position.
+  filtered_position_ = pot_relative_encoder_offset_ + info.encoder();
+  position_ = offset_ + info.encoder();
+}
+
+flatbuffers::Offset<PotAndAbsoluteEncoderZeroingEstimator::State>
+PotAndAbsoluteEncoderZeroingEstimator::GetEstimatorState(
+    flatbuffers::FlatBufferBuilder *fbb) const {
+  State::Builder builder(*fbb);
+  builder.add_error(error_);
+  builder.add_zeroed(zeroed_);
+  builder.add_position(position_);
+  builder.add_pot_position(filtered_position_);
+  builder.add_absolute_position(filtered_absolute_encoder_);
+  return builder.Finish();
+}
+
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/pot_and_absolute_encoder.h b/frc971/zeroing/pot_and_absolute_encoder.h
new file mode 100644
index 0000000..133eaf5
--- /dev/null
+++ b/frc971/zeroing/pot_and_absolute_encoder.h
@@ -0,0 +1,100 @@
+#ifndef FRC971_ZEROING_POT_AND_ABSOLUTE_ENCODER_H_
+#define FRC971_ZEROING_POT_AND_ABSOLUTE_ENCODER_H_
+
+#include <vector>
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "frc971/zeroing/zeroing.h"
+
+namespace frc971 {
+namespace zeroing {
+
+// Estimates the position with an absolute encoder which also reports
+// incremental counts, and a potentiometer.
+class PotAndAbsoluteEncoderZeroingEstimator
+    : public ZeroingEstimator<PotAndAbsolutePosition,
+                              constants::PotAndAbsoluteEncoderZeroingConstants,
+                              PotAndAbsoluteEncoderEstimatorState> {
+ public:
+  explicit PotAndAbsoluteEncoderZeroingEstimator(
+      const constants::PotAndAbsoluteEncoderZeroingConstants &constants);
+
+  // Resets the internal logic so it needs to be re-zeroed.
+  void Reset() override;
+
+  // Updates the sensor values for the zeroing logic.
+  void UpdateEstimate(const PotAndAbsolutePosition &info) override;
+
+  void TriggerError() override { error_ = true; }
+
+  bool zeroed() const override { return zeroed_; }
+
+  double offset() const override { return offset_; }
+
+  bool error() const override { return error_; }
+
+  // Returns true if the sample buffer is full.
+  bool offset_ready() const override {
+    return relative_to_absolute_offset_samples_.size() ==
+               constants_.average_filter_size &&
+           offset_samples_.size() == constants_.average_filter_size;
+  }
+
+  // Returns information about our current state.
+  virtual flatbuffers::Offset<State> GetEstimatorState(
+      flatbuffers::FlatBufferBuilder *fbb) const override;
+
+ private:
+  struct PositionStruct {
+    PositionStruct(const PotAndAbsolutePosition &position_buffer)
+        : absolute_encoder(position_buffer.absolute_encoder()),
+          encoder(position_buffer.encoder()),
+          pot(position_buffer.pot()) {}
+    double absolute_encoder;
+    double encoder;
+    double pot;
+  };
+
+  // The zeroing constants used to describe the configuration of the system.
+  const constants::PotAndAbsoluteEncoderZeroingConstants constants_;
+
+  // True if the mechanism is zeroed.
+  bool zeroed_;
+  // Marker to track whether an error has occurred.
+  bool error_;
+  // The first valid offset we recorded. This is only set after zeroed_ first
+  // changes to true.
+  double first_offset_;
+
+  // The filtered absolute encoder.  This is used in the status for calibration.
+  double filtered_absolute_encoder_ = 0.0;
+
+  // Samples of the offset needed to line the relative encoder up with the
+  // absolute encoder.
+  ::std::vector<double> relative_to_absolute_offset_samples_;
+  // Offset between the Pot and Relative encoder position.
+  ::std::vector<double> offset_samples_;
+
+  MoveDetector<PositionStruct, PotAndAbsolutePosition> move_detector_;
+
+  // Estimated offset between the pot and relative encoder.
+  double pot_relative_encoder_offset_ = 0;
+  // Estimated start position of the mechanism
+  double offset_ = 0;
+  // The next position in 'relative_to_absolute_offset_samples_' and
+  // 'encoder_samples_' to be used to store the next sample.
+  int samples_idx_ = 0;
+
+  size_t nan_samples_ = 0;
+
+  // The unzeroed filtered position.
+  double filtered_position_ = 0.0;
+  // The filtered position.
+  double position_ = 0.0;
+};
+
+}  // namespace zeroing
+}  // namespace frc971
+
+#endif  // FRC971_ZEROING_POT_AND_ABSOLUTE_ENCODER_H_
diff --git a/frc971/zeroing/pot_and_absolute_encoder_test.cc b/frc971/zeroing/pot_and_absolute_encoder_test.cc
new file mode 100644
index 0000000..ba89834
--- /dev/null
+++ b/frc971/zeroing/pot_and_absolute_encoder_test.cc
@@ -0,0 +1,143 @@
+#include "frc971/zeroing/pot_and_absolute_encoder.h"
+
+#include "gtest/gtest.h"
+
+#include "frc971/zeroing/zeroing_test.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+using constants::PotAndAbsoluteEncoderZeroingConstants;
+
+class PotAndAbsoluteEncoderZeroingTest : public ZeroingTest {
+ protected:
+  void MoveTo(PositionSensorSimulator *simulator,
+              PotAndAbsoluteEncoderZeroingEstimator *estimator,
+              double new_position) {
+    simulator->MoveTo(new_position);
+    FBB fbb;
+    estimator->UpdateEstimate(
+        *simulator->FillSensorValues<PotAndAbsolutePosition>(&fbb));
+  }
+};
+
+// Makes sure that using an absolute encoder lets us zero without moving.
+TEST_F(PotAndAbsoluteEncoderZeroingTest,
+       TestPotAndAbsoluteEncoderZeroingWithoutMovement) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+
+  const double start_pos = 2.1;
+  double measured_absolute_position = 0.3 * index_diff;
+
+  PotAndAbsoluteEncoderZeroingConstants constants{
+      kSampleSize, index_diff,        measured_absolute_position,
+      0.1,         kMovingBufferSize, kIndexErrorFraction};
+
+  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
+                 constants.measured_absolute_position);
+
+  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
+
+  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
+    MoveTo(&sim, &estimator, start_pos);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  MoveTo(&sim, &estimator, start_pos);
+  ASSERT_TRUE(estimator.zeroed());
+  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
+}
+
+// Makes sure that we ignore a NAN if we get it, but will correctly zero
+// afterwards.
+TEST_F(PotAndAbsoluteEncoderZeroingTest,
+       TestPotAndAbsoluteEncoderZeroingIgnoresNAN) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+
+  const double start_pos = 2.1;
+  double measured_absolute_position = 0.3 * index_diff;
+
+  PotAndAbsoluteEncoderZeroingConstants constants{
+      kSampleSize, index_diff,        measured_absolute_position,
+      0.1,         kMovingBufferSize, kIndexErrorFraction};
+
+  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
+                 constants.measured_absolute_position);
+
+  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
+
+  // We tolerate a couple NANs before we start.
+  FBB fbb;
+  fbb.Finish(CreatePotAndAbsolutePosition(
+      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN(), 0.0));
+  for (size_t i = 0; i < kSampleSize - 1; ++i) {
+    estimator.UpdateEstimate(
+        *flatbuffers::GetRoot<PotAndAbsolutePosition>(fbb.GetBufferPointer()));
+  }
+
+  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
+    MoveTo(&sim, &estimator, start_pos);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  MoveTo(&sim, &estimator, start_pos);
+  ASSERT_TRUE(estimator.zeroed());
+  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
+}
+
+// Makes sure that using an absolute encoder doesn't let us zero while moving.
+TEST_F(PotAndAbsoluteEncoderZeroingTest,
+       TestPotAndAbsoluteEncoderZeroingWithMovement) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+
+  const double start_pos = 10 * index_diff;
+  double measured_absolute_position = 0.3 * index_diff;
+
+  PotAndAbsoluteEncoderZeroingConstants constants{
+      kSampleSize, index_diff,        measured_absolute_position,
+      0.1,         kMovingBufferSize, kIndexErrorFraction};
+
+  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
+                 constants.measured_absolute_position);
+
+  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
+
+  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
+    MoveTo(&sim, &estimator, start_pos + i * index_diff);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+  MoveTo(&sim, &estimator, start_pos + 10 * index_diff);
+
+  MoveTo(&sim, &estimator, start_pos);
+  ASSERT_FALSE(estimator.zeroed());
+}
+
+// Makes sure we detect an error if the ZeroingEstimator gets sent a NaN.
+TEST_F(PotAndAbsoluteEncoderZeroingTest,
+       TestPotAndAbsoluteEncoderZeroingWithNaN) {
+  PotAndAbsoluteEncoderZeroingConstants constants{
+      kSampleSize, 1, 0.3, 0.1, kMovingBufferSize, kIndexErrorFraction};
+
+  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
+
+  FBB fbb;
+  fbb.Finish(CreatePotAndAbsolutePosition(
+      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN(), 0.0));
+  const auto sensor_values =
+      flatbuffers::GetRoot<PotAndAbsolutePosition>(fbb.GetBufferPointer());
+  for (size_t i = 0; i < kSampleSize - 1; ++i) {
+    estimator.UpdateEstimate(*sensor_values);
+  }
+  ASSERT_FALSE(estimator.error());
+
+  estimator.UpdateEstimate(*sensor_values);
+  ASSERT_TRUE(estimator.error());
+}
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/pot_and_index.cc b/frc971/zeroing/pot_and_index.cc
new file mode 100644
index 0000000..7c713d9
--- /dev/null
+++ b/frc971/zeroing/pot_and_index.cc
@@ -0,0 +1,135 @@
+#include "frc971/zeroing/pot_and_index.h"
+
+#include <cmath>
+
+#include "glog/logging.h"
+
+namespace frc971 {
+namespace zeroing {
+
+PotAndIndexPulseZeroingEstimator::PotAndIndexPulseZeroingEstimator(
+    const constants::PotAndIndexPulseZeroingConstants &constants)
+    : constants_(constants) {
+  start_pos_samples_.reserve(constants_.average_filter_size);
+  Reset();
+}
+
+void PotAndIndexPulseZeroingEstimator::Reset() {
+  samples_idx_ = 0;
+  offset_ = 0;
+  start_pos_samples_.clear();
+  zeroed_ = false;
+  wait_for_index_pulse_ = true;
+  last_used_index_pulse_count_ = 0;
+  error_ = false;
+}
+
+void PotAndIndexPulseZeroingEstimator::TriggerError() {
+  if (!error_) {
+    VLOG(1) << "Manually triggered zeroing error.";
+    error_ = true;
+  }
+}
+
+double PotAndIndexPulseZeroingEstimator::CalculateStartPosition(
+    double start_average, double latched_encoder) const {
+  // We calculate an aproximation of the value of the last index position.
+  // Also account for index pulses not lining up with integer multiples of the
+  // index_diff.
+  double index_pos =
+      start_average + latched_encoder - constants_.measured_index_position;
+  // We round index_pos to the closest valid value of the index.
+  double accurate_index_pos = (round(index_pos / constants_.index_difference)) *
+                              constants_.index_difference;
+  // Now we reverse the first calculation to get the accurate start position.
+  return accurate_index_pos - latched_encoder +
+         constants_.measured_index_position;
+}
+
+void PotAndIndexPulseZeroingEstimator::UpdateEstimate(
+    const PotAndIndexPosition &info) {
+  // We want to make sure that we encounter at least one index pulse while
+  // zeroing. So we take the index pulse count from the first sample after
+  // reset and wait for that count to change before we consider ourselves
+  // zeroed.
+  if (wait_for_index_pulse_) {
+    last_used_index_pulse_count_ = info.index_pulses();
+    wait_for_index_pulse_ = false;
+  }
+
+  if (start_pos_samples_.size() < constants_.average_filter_size) {
+    start_pos_samples_.push_back(info.pot() - info.encoder());
+  } else {
+    start_pos_samples_[samples_idx_] = info.pot() - info.encoder();
+  }
+
+  // Drop the oldest sample when we run this function the next time around.
+  samples_idx_ = (samples_idx_ + 1) % constants_.average_filter_size;
+
+  double sample_sum = 0.0;
+
+  for (size_t i = 0; i < start_pos_samples_.size(); ++i) {
+    sample_sum += start_pos_samples_[i];
+  }
+
+  // Calculates the average of the starting position.
+  double start_average = sample_sum / start_pos_samples_.size();
+
+  // If there are no index pulses to use or we don't have enough samples yet to
+  // have a well-filtered starting position then we use the filtered value as
+  // our best guess.
+  if (!zeroed_ &&
+      (info.index_pulses() == last_used_index_pulse_count_ || !offset_ready())) {
+    offset_ = start_average;
+  } else if (!zeroed_ || last_used_index_pulse_count_ != info.index_pulses()) {
+    // Note the accurate start position and the current index pulse count so
+    // that we only run this logic once per index pulse. That should be more
+    // resilient to corrupted intermediate data.
+    offset_ = CalculateStartPosition(start_average, info.latched_encoder());
+    last_used_index_pulse_count_ = info.index_pulses();
+
+    // TODO(austin): Reject encoder positions which have x% error rather than
+    // rounding to the closest index pulse.
+
+    // Save the first starting position.
+    if (!zeroed_) {
+      first_start_pos_ = offset_;
+      VLOG(2) << "latching start position" << first_start_pos_;
+    }
+
+    // Now that we have an accurate starting position we can consider ourselves
+    // zeroed.
+    zeroed_ = true;
+    // Throw an error if first_start_pos is bigger/smaller than
+    // constants_.allowable_encoder_error * index_diff + start_pos.
+    if (::std::abs(first_start_pos_ - offset_) >
+        constants_.allowable_encoder_error * constants_.index_difference) {
+      if (!error_) {
+        VLOG(1)
+            << "Encoder ticks out of range since last index pulse. first start "
+               "position: "
+            << first_start_pos_ << " recent starting position: " << offset_
+            << ", allowable error: "
+            << constants_.allowable_encoder_error * constants_.index_difference;
+        error_ = true;
+      }
+    }
+  }
+
+  position_ = offset_ + info.encoder();
+  filtered_position_ = start_average + info.encoder();
+}
+
+flatbuffers::Offset<PotAndIndexPulseZeroingEstimator::State>
+PotAndIndexPulseZeroingEstimator::GetEstimatorState(
+    flatbuffers::FlatBufferBuilder *fbb) const {
+  State::Builder builder(*fbb);
+  builder.add_error(error_);
+  builder.add_zeroed(zeroed_);
+  builder.add_position(position_);
+  builder.add_pot_position(filtered_position_);
+  return builder.Finish();
+}
+
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/pot_and_index.h b/frc971/zeroing/pot_and_index.h
new file mode 100644
index 0000000..473c674
--- /dev/null
+++ b/frc971/zeroing/pot_and_index.h
@@ -0,0 +1,103 @@
+#ifndef FRC971_ZEROING_POT_AND_INDEX_H_
+#define FRC971_ZEROING_POT_AND_INDEX_H_
+
+#include <vector>
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "frc971/zeroing/zeroing.h"
+
+namespace frc971 {
+namespace zeroing {
+
+// Estimates the position with an incremental encoder with an index pulse and a
+// potentiometer.
+class PotAndIndexPulseZeroingEstimator
+    : public ZeroingEstimator<PotAndIndexPosition,
+                              constants::PotAndIndexPulseZeroingConstants,
+                              EstimatorState> {
+ public:
+  explicit PotAndIndexPulseZeroingEstimator(
+      const constants::PotAndIndexPulseZeroingConstants &constants);
+
+  // Update the internal logic with the next sensor values.
+  void UpdateEstimate(const PotAndIndexPosition &info) override;
+
+  // Reset the internal logic so it needs to be re-zeroed.
+  void Reset() override;
+
+  // Manually trigger an internal error. This is used for testing the error
+  // logic.
+  void TriggerError() override;
+
+  bool error() const override { return error_; }
+
+  bool zeroed() const override { return zeroed_; }
+
+  double offset() const override { return offset_; }
+
+  // Returns a number between 0 and 1 that represents the percentage of the
+  // samples being used in the moving average filter. A value of 0.0 means that
+  // no samples are being used. A value of 1.0 means that the filter is using
+  // as many samples as it has room for. For example, after a Reset() this
+  // value returns 0.0. As more samples get added with UpdateEstimate(...) the
+  // return value starts increasing to 1.0.
+  double offset_ratio_ready() const {
+    return start_pos_samples_.size() /
+           static_cast<double>(constants_.average_filter_size);
+  }
+
+  // Returns true if the sample buffer is full.
+  bool offset_ready() const override {
+    return start_pos_samples_.size() == constants_.average_filter_size;
+  }
+
+  // Returns information about our current state.
+  virtual flatbuffers::Offset<State> GetEstimatorState(
+      flatbuffers::FlatBufferBuilder *fbb) const override;
+
+ private:
+  // This function calculates the start position given the internal state and
+  // the provided `latched_encoder' value.
+  double CalculateStartPosition(double start_average,
+                                double latched_encoder) const;
+
+  // The zeroing constants used to describe the configuration of the system.
+  const constants::PotAndIndexPulseZeroingConstants constants_;
+
+  // The estimated position.
+  double position_;
+  // The unzeroed filtered position.
+  double filtered_position_ = 0.0;
+  // The next position in 'start_pos_samples_' to be used to store the next
+  // sample.
+  int samples_idx_;
+  // Last 'max_sample_count_' samples for start positions.
+  std::vector<double> start_pos_samples_;
+  // The estimated starting position of the mechanism. We also call this the
+  // 'offset' in some contexts.
+  double offset_;
+  // Flag for triggering logic that takes note of the current index pulse count
+  // after a reset. See `last_used_index_pulse_count_'.
+  bool wait_for_index_pulse_;
+  // After a reset we keep track of the index pulse count with this. Only after
+  // the index pulse count changes (i.e. increments at least once or wraps
+  // around) will we consider the mechanism zeroed. We also use this to store
+  // the most recent `PotAndIndexPosition::index_pulses' value when the start
+  // position was calculated. It helps us calculate the start position only on
+  // index pulses to reject corrupted intermediate data.
+  uint32_t last_used_index_pulse_count_;
+  // Marker to track whether we're fully zeroed yet or not.
+  bool zeroed_;
+  // Marker to track whether an error has occurred. This gets reset to false
+  // whenever Reset() is called.
+  bool error_;
+  // Stores the position "start_pos" variable the first time the program
+  // is zeroed.
+  double first_start_pos_;
+};
+
+}  // namespace zeroing
+}  // namespace frc971
+
+#endif  // FRC971_ZEROING_POT_AND_INDEX_H_
diff --git a/frc971/zeroing/pot_and_index_test.cc b/frc971/zeroing/pot_and_index_test.cc
new file mode 100644
index 0000000..b2b00ce
--- /dev/null
+++ b/frc971/zeroing/pot_and_index_test.cc
@@ -0,0 +1,283 @@
+#include "frc971/zeroing/pot_and_index.h"
+
+#include "gtest/gtest.h"
+
+#include "frc971/zeroing/zeroing_test.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+using constants::PotAndIndexPulseZeroingConstants;
+
+class PotAndIndexZeroingTest : public ZeroingTest {
+ protected:
+  void MoveTo(PositionSensorSimulator *simulator,
+              PotAndIndexPulseZeroingEstimator *estimator,
+              double new_position) {
+    simulator->MoveTo(new_position);
+    FBB fbb;
+    estimator->UpdateEstimate(
+        *simulator->FillSensorValues<PotAndIndexPosition>(&fbb));
+  }
+};
+
+TEST_F(PotAndIndexZeroingTest, TestMovingAverageFilter) {
+  const double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.6 * index_diff, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  // The zeroing code is supposed to perform some filtering on the difference
+  // between the potentiometer value and the encoder value. We assume that 300
+  // samples are sufficient to have updated the filter.
+  for (int i = 0; i < 300; i++) {
+    MoveTo(&sim, &estimator, 3.3 * index_diff);
+  }
+  ASSERT_NEAR(3.3 * index_diff, GetEstimatorPosition(&estimator),
+              kAcceptableUnzeroedError * index_diff);
+
+  for (int i = 0; i < 300; i++) {
+    MoveTo(&sim, &estimator, 3.9 * index_diff);
+  }
+  ASSERT_NEAR(3.9 * index_diff, GetEstimatorPosition(&estimator),
+              kAcceptableUnzeroedError * index_diff);
+}
+
+TEST_F(PotAndIndexZeroingTest, NotZeroedBeforeEnoughSamplesCollected) {
+  double index_diff = 0.5;
+  double position = 3.6 * index_diff;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(position, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  // Make sure that the zeroing code does not consider itself zeroed until we
+  // collect a good amount of samples. In this case we're waiting until the
+  // moving average filter is full.
+  for (unsigned int i = 0; i < kSampleSize - 1; i++) {
+    MoveTo(&sim, &estimator, position += index_diff);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  MoveTo(&sim, &estimator, position);
+  ASSERT_TRUE(estimator.zeroed());
+}
+
+TEST_F(PotAndIndexZeroingTest, TestLotsOfMovement) {
+  double index_diff = 1.0;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.6, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  // The zeroing code is supposed to perform some filtering on the difference
+  // between the potentiometer value and the encoder value. We assume that 300
+  // samples are sufficient to have updated the filter.
+  for (int i = 0; i < 300; i++) {
+    MoveTo(&sim, &estimator, 3.6);
+  }
+  ASSERT_NEAR(3.6, GetEstimatorPosition(&estimator),
+              kAcceptableUnzeroedError * index_diff);
+
+  // With a single index pulse the zeroing estimator should be able to lock
+  // onto the true value of the position.
+  MoveTo(&sim, &estimator, 4.01);
+  ASSERT_NEAR(4.01, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 4.99);
+  ASSERT_NEAR(4.99, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 3.99);
+  ASSERT_NEAR(3.99, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 3.01);
+  ASSERT_NEAR(3.01, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 13.55);
+  ASSERT_NEAR(13.55, GetEstimatorPosition(&estimator), 0.001);
+}
+
+TEST_F(PotAndIndexZeroingTest, TestDifferentIndexDiffs) {
+  double index_diff = 0.89;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.5 * index_diff, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  // The zeroing code is supposed to perform some filtering on the difference
+  // between the potentiometer value and the encoder value. We assume that 300
+  // samples are sufficient to have updated the filter.
+  for (int i = 0; i < 300; i++) {
+    MoveTo(&sim, &estimator, 3.5 * index_diff);
+  }
+  ASSERT_NEAR(3.5 * index_diff, GetEstimatorPosition(&estimator),
+              kAcceptableUnzeroedError * index_diff);
+
+  // With a single index pulse the zeroing estimator should be able to lock
+  // onto the true value of the position.
+  MoveTo(&sim, &estimator, 4.01);
+  ASSERT_NEAR(4.01, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 4.99);
+  ASSERT_NEAR(4.99, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 3.99);
+  ASSERT_NEAR(3.99, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 3.01);
+  ASSERT_NEAR(3.01, GetEstimatorPosition(&estimator), 0.001);
+
+  MoveTo(&sim, &estimator, 13.55);
+  ASSERT_NEAR(13.55, GetEstimatorPosition(&estimator), 0.001);
+}
+
+TEST_F(PotAndIndexZeroingTest, TestPercentage) {
+  double index_diff = 0.89;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.5 * index_diff, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  for (unsigned int i = 0; i < kSampleSize / 2; i++) {
+    MoveTo(&sim, &estimator, 3.5 * index_diff);
+  }
+  ASSERT_NEAR(0.5, estimator.offset_ratio_ready(), 0.001);
+  ASSERT_FALSE(estimator.offset_ready());
+
+  for (unsigned int i = 0; i < kSampleSize / 2; i++) {
+    MoveTo(&sim, &estimator, 3.5 * index_diff);
+  }
+  ASSERT_NEAR(1.0, estimator.offset_ratio_ready(), 0.001);
+  ASSERT_TRUE(estimator.offset_ready());
+}
+
+TEST_F(PotAndIndexZeroingTest, TestOffset) {
+  double index_diff = 0.89;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.1 * index_diff, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  MoveTo(&sim, &estimator, 3.1 * index_diff);
+
+  for (unsigned int i = 0; i < kSampleSize; i++) {
+    MoveTo(&sim, &estimator, 5.0 * index_diff);
+  }
+
+  ASSERT_NEAR(3.1 * index_diff, estimator.offset(), 0.001);
+}
+
+TEST_F(PotAndIndexZeroingTest, WaitForIndexPulseAfterReset) {
+  double index_diff = 0.6;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.1 * index_diff, index_diff / 3.0);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+
+  // Make sure to fill up the averaging filter with samples.
+  for (unsigned int i = 0; i < kSampleSize; i++) {
+    MoveTo(&sim, &estimator, 3.1 * index_diff);
+  }
+
+  // Make sure we're not zeroed until we hit an index pulse.
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Trigger an index pulse; we should now be zeroed.
+  MoveTo(&sim, &estimator, 4.5 * index_diff);
+  ASSERT_TRUE(estimator.zeroed());
+
+  // Reset the zeroing logic and supply a bunch of samples within the current
+  // index segment.
+  estimator.Reset();
+  for (unsigned int i = 0; i < kSampleSize; i++) {
+    MoveTo(&sim, &estimator, 4.2 * index_diff);
+  }
+
+  // Make sure we're not zeroed until we hit an index pulse.
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Trigger another index pulse; we should be zeroed again.
+  MoveTo(&sim, &estimator, 3.1 * index_diff);
+  ASSERT_TRUE(estimator.zeroed());
+}
+
+TEST_F(PotAndIndexZeroingTest, TestNonZeroIndexPulseOffsets) {
+  const double index_diff = 0.9;
+  const double known_index_pos = 3.5 * index_diff;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(3.3 * index_diff, index_diff / 3.0, known_index_pos);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, known_index_pos, kIndexErrorFraction});
+
+  // Make sure to fill up the averaging filter with samples.
+  for (unsigned int i = 0; i < kSampleSize; i++) {
+    MoveTo(&sim, &estimator, 3.3 * index_diff);
+  }
+
+  // Make sure we're not zeroed until we hit an index pulse.
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Trigger an index pulse; we should now be zeroed.
+  MoveTo(&sim, &estimator, 3.7 * index_diff);
+  ASSERT_TRUE(estimator.zeroed());
+  ASSERT_DOUBLE_EQ(3.3 * index_diff, estimator.offset());
+  ASSERT_DOUBLE_EQ(3.7 * index_diff, GetEstimatorPosition(&estimator));
+
+  // Trigger one more index pulse and check the offset.
+  MoveTo(&sim, &estimator, 4.7 * index_diff);
+  ASSERT_DOUBLE_EQ(3.3 * index_diff, estimator.offset());
+  ASSERT_DOUBLE_EQ(4.7 * index_diff, GetEstimatorPosition(&estimator));
+}
+
+TEST_F(PotAndIndexZeroingTest, BasicErrorAPITest) {
+  const double index_diff = 1.0;
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(1.5 * index_diff, index_diff / 3.0, 0.0);
+
+  // Perform a simple move and make sure that no error occured.
+  MoveTo(&sim, &estimator, 3.5 * index_diff);
+  ASSERT_FALSE(estimator.error());
+
+  // Trigger an error and make sure it's reported.
+  estimator.TriggerError();
+  ASSERT_TRUE(estimator.error());
+
+  // Make sure that it can recover after a reset.
+  estimator.Reset();
+  ASSERT_FALSE(estimator.error());
+  MoveTo(&sim, &estimator, 4.5 * index_diff);
+  MoveTo(&sim, &estimator, 5.5 * index_diff);
+  ASSERT_FALSE(estimator.error());
+}
+
+// Tests that an error is detected when the starting position changes too much.
+TEST_F(PotAndIndexZeroingTest, TestIndexOffsetError) {
+  const double index_diff = 0.8;
+  const double known_index_pos = 2 * index_diff;
+  const size_t sample_size = 30;
+  PositionSensorSimulator sim(index_diff);
+  sim.Initialize(10 * index_diff, index_diff / 3.0, known_index_pos);
+  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
+      sample_size, index_diff, known_index_pos, kIndexErrorFraction});
+
+  for (size_t i = 0; i < sample_size; i++) {
+    MoveTo(&sim, &estimator, 13 * index_diff);
+  }
+  MoveTo(&sim, &estimator, 8 * index_diff);
+
+  ASSERT_TRUE(estimator.zeroed());
+  ASSERT_FALSE(estimator.error());
+  sim.Initialize(9.0 * index_diff + 0.31 * index_diff, index_diff / 3.0,
+                 known_index_pos);
+  MoveTo(&sim, &estimator, 9 * index_diff);
+  ASSERT_TRUE(estimator.zeroed());
+  ASSERT_TRUE(estimator.error());
+}
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/pulse_index.cc b/frc971/zeroing/pulse_index.cc
new file mode 100644
index 0000000..c0831e8
--- /dev/null
+++ b/frc971/zeroing/pulse_index.cc
@@ -0,0 +1,116 @@
+#include "frc971/zeroing/pulse_index.h"
+
+#include <cmath>
+#include <limits>
+
+#include "glog/logging.h"
+
+namespace frc971 {
+namespace zeroing {
+
+void PulseIndexZeroingEstimator::Reset() {
+  max_index_position_ = ::std::numeric_limits<double>::lowest();
+  min_index_position_ = ::std::numeric_limits<double>::max();
+  offset_ = 0;
+  last_used_index_pulse_count_ = 0;
+  zeroed_ = false;
+  error_ = false;
+}
+
+void PulseIndexZeroingEstimator::StoreIndexPulseMaxAndMin(
+    const IndexPosition &info) {
+  // If we have a new index pulse.
+  if (last_used_index_pulse_count_ != info.index_pulses()) {
+    // If the latest pulses's position is outside the range we've currently
+    // seen, record it appropriately.
+    if (info.latched_encoder() > max_index_position_) {
+      max_index_position_ = info.latched_encoder();
+    }
+    if (info.latched_encoder() < min_index_position_) {
+      min_index_position_ = info.latched_encoder();
+    }
+    last_used_index_pulse_count_ = info.index_pulses();
+  }
+}
+
+int PulseIndexZeroingEstimator::IndexPulseCount() const {
+  if (min_index_position_ > max_index_position_) {
+    // This condition means we haven't seen a pulse yet.
+    return 0;
+  }
+
+  // Calculate the number of pulses encountered so far.
+  return 1 + static_cast<int>(
+                 ::std::round((max_index_position_ - min_index_position_) /
+                              constants_.index_difference));
+}
+
+void PulseIndexZeroingEstimator::UpdateEstimate(const IndexPosition &info) {
+  StoreIndexPulseMaxAndMin(info);
+  const int index_pulse_count = IndexPulseCount();
+  if (index_pulse_count > constants_.index_pulse_count) {
+    if (!error_) {
+      VLOG(1) << "Got more index pulses than expected. Got "
+              << index_pulse_count << " expected "
+              << constants_.index_pulse_count;
+      error_ = true;
+    }
+  }
+
+  // TODO(austin): Detect if the encoder or index pulse is unplugged.
+  // TODO(austin): Detect missing counts.
+
+  if (index_pulse_count == constants_.index_pulse_count && !zeroed_) {
+    offset_ = constants_.measured_index_position -
+              constants_.known_index_pulse * constants_.index_difference -
+              min_index_position_;
+    zeroed_ = true;
+  } else if (zeroed_ && !error_) {
+    // Detect whether the index pulse is somewhere other than where we expect
+    // it to be. First we compute the position of the most recent index pulse.
+    double index_pulse_distance =
+        info.latched_encoder() + offset_ - constants_.measured_index_position;
+    // Second we compute the position of the index pulse in terms of
+    // the index difference. I.e. if this index pulse is two pulses away from
+    // the index pulse that we know about then this number should be positive
+    // or negative two.
+    double relative_distance =
+        index_pulse_distance / constants_.index_difference;
+    // Now we compute how far away the measured index pulse is from the
+    // expected index pulse.
+    double error = relative_distance - ::std::round(relative_distance);
+    // This lets us check if the index pulse is within an acceptable error
+    // margin of where we expected it to be.
+    if (::std::abs(error) > constants_.allowable_encoder_error) {
+      VLOG(1)
+          << "Encoder ticks out of range since last index pulse. known index "
+             "pulse: "
+          << constants_.measured_index_position << ", expected index pulse: "
+          << round(relative_distance) * constants_.index_difference +
+                 constants_.measured_index_position
+          << ", actual index pulse: " << info.latched_encoder() + offset_
+          << ", "
+             "allowable error: "
+          << constants_.allowable_encoder_error * constants_.index_difference;
+      error_ = true;
+    }
+  }
+
+  position_ = info.encoder() + offset_;
+}
+
+flatbuffers::Offset<PulseIndexZeroingEstimator::State>
+PulseIndexZeroingEstimator::GetEstimatorState(
+    flatbuffers::FlatBufferBuilder *fbb) const {
+  State::Builder builder(*fbb);
+  builder.add_error(error_);
+  builder.add_zeroed(zeroed_);
+  builder.add_position(position_);
+  builder.add_min_index_position(min_index_position_);
+  builder.add_max_index_position(max_index_position_);
+  builder.add_index_pulses_seen(IndexPulseCount());
+  return builder.Finish();
+}
+
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/pulse_index.h b/frc971/zeroing/pulse_index.h
new file mode 100644
index 0000000..4bcf210
--- /dev/null
+++ b/frc971/zeroing/pulse_index.h
@@ -0,0 +1,84 @@
+#ifndef FRC971_ZEROING_PULSE_INDEX_H_
+#define FRC971_ZEROING_PULSE_INDEX_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "frc971/zeroing/zeroing.h"
+
+namespace frc971 {
+namespace zeroing {
+
+// Zeros by seeing all the index pulses in the range of motion of the mechanism
+// and using that to figure out which index pulse is which.
+class PulseIndexZeroingEstimator
+    : public ZeroingEstimator<IndexPosition,
+                              constants::EncoderPlusIndexZeroingConstants,
+                              IndexEstimatorState> {
+ public:
+  explicit PulseIndexZeroingEstimator(const ZeroingConstants &constants)
+      : constants_(constants) {
+    Reset();
+  }
+
+  // Resets the internal logic so it needs to be re-zeroed.
+  void Reset() override;
+
+  bool zeroed() const override { return zeroed_; }
+
+  // It's as ready as it'll ever be...
+  bool offset_ready() const override { return true; }
+
+  double offset() const override { return offset_; }
+
+  bool error() const override { return error_; }
+
+  // Updates the internal logic with the next sensor values.
+  void UpdateEstimate(const IndexPosition &info) override;
+
+  // Returns information about our current state.
+  virtual flatbuffers::Offset<State> GetEstimatorState(
+      flatbuffers::FlatBufferBuilder *fbb) const override;
+
+  void TriggerError() override { error_ = true; }
+
+ private:
+  // Returns the current real position using the relative encoder offset.
+  double CalculateCurrentPosition(const IndexPosition &info);
+
+  // Sets the minimum and maximum index pulse position values.
+  void StoreIndexPulseMaxAndMin(const IndexPosition &info);
+
+  // Returns the number of index pulses we should have seen so far.
+  int IndexPulseCount() const;
+
+  // Contains the physical constants describing the system.
+  const ZeroingConstants constants_;
+
+  // The smallest position of all the index pulses.
+  double min_index_position_;
+  // The largest position of all the index pulses.
+  double max_index_position_;
+
+  // The estimated starting position of the mechanism.
+  double offset_;
+  // After a reset we keep track of the index pulse count with this. Only after
+  // the index pulse count changes (i.e. increments at least once or wraps
+  // around) will we consider the mechanism zeroed. We also use this to store
+  // the most recent `PotAndIndexPosition::index_pulses' value when the start
+  // position was calculated. It helps us calculate the start position only on
+  // index pulses to reject corrupted intermediate data.
+  uint32_t last_used_index_pulse_count_;
+
+  // True if we are fully zeroed.
+  bool zeroed_;
+  // Marker to track whether an error has occurred.
+  bool error_;
+
+  // The estimated position.
+  double position_;
+};
+
+}  // namespace zeroing
+}  // namespace frc971
+
+#endif  // FRC971_ZEROING_PULSE_INDEX_H_
diff --git a/frc971/zeroing/pulse_index_test.cc b/frc971/zeroing/pulse_index_test.cc
new file mode 100644
index 0000000..bd257f7
--- /dev/null
+++ b/frc971/zeroing/pulse_index_test.cc
@@ -0,0 +1,132 @@
+#include "frc971/zeroing/pulse_index.h"
+
+#include "gtest/gtest.h"
+
+#include "frc971/zeroing/zeroing_test.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+using constants::EncoderPlusIndexZeroingConstants;
+
+class PulseIndexZeroingTest : public ZeroingTest {
+ protected:
+  void MoveTo(PositionSensorSimulator *simulator,
+              PulseIndexZeroingEstimator *estimator, double new_position) {
+    simulator->MoveTo(new_position);
+    FBB fbb;
+    estimator->UpdateEstimate(
+        *simulator->FillSensorValues<IndexPosition>(&fbb));
+  }
+};
+
+// Tests that an error is detected when the starting position changes too much.
+TEST_F(PulseIndexZeroingTest, TestRelativeEncoderZeroing) {
+  EncoderPlusIndexZeroingConstants constants;
+  constants.index_pulse_count = 3;
+  constants.index_difference = 10.0;
+  constants.measured_index_position = 20.0;
+  constants.known_index_pulse = 1;
+  constants.allowable_encoder_error = 0.01;
+
+  PositionSensorSimulator sim(constants.index_difference);
+
+  const double start_pos = 2.5 * constants.index_difference;
+
+  sim.Initialize(start_pos, constants.index_difference / 3.0,
+                 constants.measured_index_position);
+
+  PulseIndexZeroingEstimator estimator(constants);
+
+  // Should not be zeroed when we stand still.
+  for (int i = 0; i < 300; ++i) {
+    MoveTo(&sim, &estimator, start_pos);
+    ASSERT_FALSE(estimator.zeroed());
+  }
+
+  // Move to 1.5 constants.index_difference and we should still not be zeroed.
+  MoveTo(&sim, &estimator, 1.5 * constants.index_difference);
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Move to 0.5 constants.index_difference and we should still not be zeroed.
+  MoveTo(&sim, &estimator, 0.5 * constants.index_difference);
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Move back to 1.5 constants.index_difference and we should still not be
+  // zeroed.
+  MoveTo(&sim, &estimator, 1.5 * constants.index_difference);
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Move back to 2.5 constants.index_difference and we should still not be
+  // zeroed.
+  MoveTo(&sim, &estimator, 2.5 * constants.index_difference);
+  ASSERT_FALSE(estimator.zeroed());
+
+  // Move back to 3.5 constants.index_difference and we should now be zeroed.
+  MoveTo(&sim, &estimator, 3.5 * constants.index_difference);
+  ASSERT_TRUE(estimator.zeroed());
+
+  ASSERT_DOUBLE_EQ(start_pos, estimator.offset());
+  ASSERT_DOUBLE_EQ(3.5 * constants.index_difference,
+                   GetEstimatorPosition(&estimator));
+
+  MoveTo(&sim, &estimator, 0.5 * constants.index_difference);
+  ASSERT_DOUBLE_EQ(0.5 * constants.index_difference,
+                   GetEstimatorPosition(&estimator));
+}
+
+// Tests that we can detect when an index pulse occurs where we didn't expect
+// it to for the PulseIndexZeroingEstimator.
+TEST_F(PulseIndexZeroingTest, TestRelativeEncoderSlipping) {
+  EncoderPlusIndexZeroingConstants constants;
+  constants.index_pulse_count = 3;
+  constants.index_difference = 10.0;
+  constants.measured_index_position = 20.0;
+  constants.known_index_pulse = 1;
+  constants.allowable_encoder_error = 0.05;
+
+  PositionSensorSimulator sim(constants.index_difference);
+
+  const double start_pos =
+      constants.measured_index_position + 0.5 * constants.index_difference;
+
+  for (double direction : {1.0, -1.0}) {
+    sim.Initialize(start_pos, constants.index_difference / 3.0,
+                   constants.measured_index_position);
+
+    PulseIndexZeroingEstimator estimator(constants);
+
+    // Zero the estimator.
+    MoveTo(&sim, &estimator, start_pos - 1 * constants.index_difference);
+    MoveTo(
+        &sim, &estimator,
+        start_pos - constants.index_pulse_count * constants.index_difference);
+    ASSERT_TRUE(estimator.zeroed());
+    ASSERT_FALSE(estimator.error());
+
+    // We have a 5% allowable error so we slip a little bit each time and make
+    // sure that the index pulses are still accepted.
+    for (double error = 0.00;
+         ::std::abs(error) < constants.allowable_encoder_error;
+         error += 0.01 * direction) {
+      sim.Initialize(start_pos, constants.index_difference / 3.0,
+                     constants.measured_index_position +
+                         error * constants.index_difference);
+      MoveTo(&sim, &estimator, start_pos - constants.index_difference);
+      EXPECT_FALSE(estimator.error());
+    }
+
+    // As soon as we hit cross the error margin, we should trigger an error.
+    sim.Initialize(start_pos, constants.index_difference / 3.0,
+                   constants.measured_index_position +
+                       constants.allowable_encoder_error * 1.1 *
+                           constants.index_difference * direction);
+    MoveTo(&sim, &estimator, start_pos - constants.index_difference);
+    ASSERT_TRUE(estimator.error());
+  }
+}
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/relative_encoder_test.cc b/frc971/zeroing/relative_encoder_test.cc
new file mode 100644
index 0000000..fd86fb3
--- /dev/null
+++ b/frc971/zeroing/relative_encoder_test.cc
@@ -0,0 +1,40 @@
+#include "frc971/zeroing/zeroing.h"
+
+#include "gtest/gtest.h"
+
+#include "frc971/zeroing/zeroing_test.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+class RelativeEncoderZeroingTest : public ZeroingTest {
+ protected:
+  void MoveTo(PositionSensorSimulator *simulator,
+              RelativeEncoderZeroingEstimator *estimator, double new_position) {
+    simulator->MoveTo(new_position);
+    FBB fbb;
+    estimator->UpdateEstimate(
+        *simulator->FillSensorValues<RelativePosition>(&fbb));
+  }
+};
+
+TEST_F(RelativeEncoderZeroingTest, TestRelativeEncoderZeroingWithoutMovement) {
+  PositionSensorSimulator sim(1.0);
+  RelativeEncoderZeroingEstimator estimator;
+
+  sim.InitializeRelativeEncoder();
+
+  ASSERT_TRUE(estimator.zeroed());
+  ASSERT_TRUE(estimator.offset_ready());
+  EXPECT_DOUBLE_EQ(estimator.offset(), 0.0);
+  EXPECT_DOUBLE_EQ(GetEstimatorPosition(&estimator), 0.0);
+
+  MoveTo(&sim, &estimator, 0.1);
+
+  EXPECT_DOUBLE_EQ(GetEstimatorPosition(&estimator), 0.1);
+}
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/frc971/zeroing/zeroing.cc b/frc971/zeroing/zeroing.cc
deleted file mode 100644
index f0aab23..0000000
--- a/frc971/zeroing/zeroing.cc
+++ /dev/null
@@ -1,706 +0,0 @@
-#include "frc971/zeroing/zeroing.h"
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <numeric>
-#include <vector>
-
-#include "frc971/zeroing/wrap.h"
-
-#include "flatbuffers/flatbuffers.h"
-#include "glog/logging.h"
-
-namespace frc971 {
-namespace zeroing {
-
-PotAndIndexPulseZeroingEstimator::PotAndIndexPulseZeroingEstimator(
-    const constants::PotAndIndexPulseZeroingConstants &constants)
-    : constants_(constants) {
-  start_pos_samples_.reserve(constants_.average_filter_size);
-  Reset();
-}
-
-void PotAndIndexPulseZeroingEstimator::Reset() {
-  samples_idx_ = 0;
-  offset_ = 0;
-  start_pos_samples_.clear();
-  zeroed_ = false;
-  wait_for_index_pulse_ = true;
-  last_used_index_pulse_count_ = 0;
-  error_ = false;
-}
-
-void PotAndIndexPulseZeroingEstimator::TriggerError() {
-  if (!error_) {
-    VLOG(1) << "Manually triggered zeroing error.";
-    error_ = true;
-  }
-}
-
-double PotAndIndexPulseZeroingEstimator::CalculateStartPosition(
-    double start_average, double latched_encoder) const {
-  // We calculate an aproximation of the value of the last index position.
-  // Also account for index pulses not lining up with integer multiples of the
-  // index_diff.
-  double index_pos =
-      start_average + latched_encoder - constants_.measured_index_position;
-  // We round index_pos to the closest valid value of the index.
-  double accurate_index_pos = (round(index_pos / constants_.index_difference)) *
-                              constants_.index_difference;
-  // Now we reverse the first calculation to get the accurate start position.
-  return accurate_index_pos - latched_encoder +
-         constants_.measured_index_position;
-}
-
-void PotAndIndexPulseZeroingEstimator::UpdateEstimate(
-    const PotAndIndexPosition &info) {
-  // We want to make sure that we encounter at least one index pulse while
-  // zeroing. So we take the index pulse count from the first sample after
-  // reset and wait for that count to change before we consider ourselves
-  // zeroed.
-  if (wait_for_index_pulse_) {
-    last_used_index_pulse_count_ = info.index_pulses();
-    wait_for_index_pulse_ = false;
-  }
-
-  if (start_pos_samples_.size() < constants_.average_filter_size) {
-    start_pos_samples_.push_back(info.pot() - info.encoder());
-  } else {
-    start_pos_samples_[samples_idx_] = info.pot() - info.encoder();
-  }
-
-  // Drop the oldest sample when we run this function the next time around.
-  samples_idx_ = (samples_idx_ + 1) % constants_.average_filter_size;
-
-  double sample_sum = 0.0;
-
-  for (size_t i = 0; i < start_pos_samples_.size(); ++i) {
-    sample_sum += start_pos_samples_[i];
-  }
-
-  // Calculates the average of the starting position.
-  double start_average = sample_sum / start_pos_samples_.size();
-
-  // If there are no index pulses to use or we don't have enough samples yet to
-  // have a well-filtered starting position then we use the filtered value as
-  // our best guess.
-  if (!zeroed_ &&
-      (info.index_pulses() == last_used_index_pulse_count_ || !offset_ready())) {
-    offset_ = start_average;
-  } else if (!zeroed_ || last_used_index_pulse_count_ != info.index_pulses()) {
-    // Note the accurate start position and the current index pulse count so
-    // that we only run this logic once per index pulse. That should be more
-    // resilient to corrupted intermediate data.
-    offset_ = CalculateStartPosition(start_average, info.latched_encoder());
-    last_used_index_pulse_count_ = info.index_pulses();
-
-    // TODO(austin): Reject encoder positions which have x% error rather than
-    // rounding to the closest index pulse.
-
-    // Save the first starting position.
-    if (!zeroed_) {
-      first_start_pos_ = offset_;
-      VLOG(2) << "latching start position" << first_start_pos_;
-    }
-
-    // Now that we have an accurate starting position we can consider ourselves
-    // zeroed.
-    zeroed_ = true;
-    // Throw an error if first_start_pos is bigger/smaller than
-    // constants_.allowable_encoder_error * index_diff + start_pos.
-    if (::std::abs(first_start_pos_ - offset_) >
-        constants_.allowable_encoder_error * constants_.index_difference) {
-      if (!error_) {
-        VLOG(1)
-            << "Encoder ticks out of range since last index pulse. first start "
-               "position: "
-            << first_start_pos_ << " recent starting position: " << offset_
-            << ", allowable error: "
-            << constants_.allowable_encoder_error * constants_.index_difference;
-        error_ = true;
-      }
-    }
-  }
-
-  position_ = offset_ + info.encoder();
-  filtered_position_ = start_average + info.encoder();
-}
-
-flatbuffers::Offset<PotAndIndexPulseZeroingEstimator::State>
-PotAndIndexPulseZeroingEstimator::GetEstimatorState(
-    flatbuffers::FlatBufferBuilder *fbb) const {
-  State::Builder builder(*fbb);
-  builder.add_error(error_);
-  builder.add_zeroed(zeroed_);
-  builder.add_position(position_);
-  builder.add_pot_position(filtered_position_);
-  return builder.Finish();
-}
-
-HallEffectAndPositionZeroingEstimator::HallEffectAndPositionZeroingEstimator(
-    const ZeroingConstants &constants)
-    : constants_(constants) {
-  Reset();
-}
-
-void HallEffectAndPositionZeroingEstimator::Reset() {
-  offset_ = 0.0;
-  min_low_position_ = ::std::numeric_limits<double>::max();
-  max_low_position_ = ::std::numeric_limits<double>::lowest();
-  zeroed_ = false;
-  initialized_ = false;
-  last_used_posedge_count_ = 0;
-  cycles_high_ = 0;
-  high_long_enough_ = false;
-  first_start_pos_ = 0.0;
-  error_ = false;
-  current_ = 0.0;
-  first_start_pos_ = 0.0;
-}
-
-void HallEffectAndPositionZeroingEstimator::TriggerError() {
-  if (!error_) {
-    VLOG(1) << "Manually triggered zeroing error.\n";
-    error_ = true;
-  }
-}
-
-void HallEffectAndPositionZeroingEstimator::StoreEncoderMaxAndMin(
-    const HallEffectAndPosition &info) {
-  // If we have a new posedge.
-  if (!info.current()) {
-    if (last_hall_) {
-      min_low_position_ = max_low_position_ = info.encoder();
-    } else {
-      min_low_position_ = ::std::min(min_low_position_, info.encoder());
-      max_low_position_ = ::std::max(max_low_position_, info.encoder());
-    }
-  }
-  last_hall_ = info.current();
-}
-
-void HallEffectAndPositionZeroingEstimator::UpdateEstimate(
-    const HallEffectAndPosition &info) {
-  // We want to make sure that we encounter at least one posedge while zeroing.
-  // So we take the posedge count from the first sample after reset and wait for
-  // that count to change and for the hall effect to stay high before we
-  // consider ourselves zeroed.
-  if (!initialized_) {
-    last_used_posedge_count_ = info.posedge_count();
-    initialized_ = true;
-    last_hall_ = info.current();
-  }
-
-  StoreEncoderMaxAndMin(info);
-
-  if (info.current()) {
-    cycles_high_++;
-  } else {
-    cycles_high_ = 0;
-    last_used_posedge_count_ = info.posedge_count();
-  }
-
-  high_long_enough_ = cycles_high_ >= constants_.hall_trigger_zeroing_length;
-
-  bool moving_backward = false;
-  if (constants_.zeroing_move_direction) {
-    moving_backward = info.encoder() > min_low_position_;
-  } else {
-    moving_backward = info.encoder() < max_low_position_;
-  }
-
-  // If there are no posedges to use or we don't have enough samples yet to
-  // have a well-filtered starting position then we use the filtered value as
-  // our best guess.
-  if (last_used_posedge_count_ != info.posedge_count() && high_long_enough_ &&
-      moving_backward) {
-    // Note the offset and the current posedge count so that we only run this
-    // logic once per posedge. That should be more resilient to corrupted
-    // intermediate data.
-    offset_ = -info.posedge_value();
-    if (constants_.zeroing_move_direction) {
-      offset_ += constants_.lower_hall_position;
-    } else {
-      offset_ += constants_.upper_hall_position;
-    }
-    last_used_posedge_count_ = info.posedge_count();
-
-    // Save the first starting position.
-    if (!zeroed_) {
-      first_start_pos_ = offset_;
-      VLOG(2) << "latching start position" << first_start_pos_;
-    }
-
-    // Now that we have an accurate starting position we can consider ourselves
-    // zeroed.
-    zeroed_ = true;
-  }
-
-  position_ = info.encoder() - offset_;
-}
-
-flatbuffers::Offset<HallEffectAndPositionZeroingEstimator::State>
-HallEffectAndPositionZeroingEstimator::GetEstimatorState(
-    flatbuffers::FlatBufferBuilder *fbb) const {
-  State::Builder builder(*fbb);
-  builder.add_error(error_);
-  builder.add_zeroed(zeroed_);
-  builder.add_encoder(position_);
-  builder.add_high_long_enough(high_long_enough_);
-  builder.add_offset(offset_);
-  return builder.Finish();
-}
-
-PotAndAbsoluteEncoderZeroingEstimator::PotAndAbsoluteEncoderZeroingEstimator(
-    const constants::PotAndAbsoluteEncoderZeroingConstants &constants)
-    : constants_(constants), move_detector_(constants_.moving_buffer_size) {
-  relative_to_absolute_offset_samples_.reserve(constants_.average_filter_size);
-  offset_samples_.reserve(constants_.average_filter_size);
-  Reset();
-}
-
-void PotAndAbsoluteEncoderZeroingEstimator::Reset() {
-  first_offset_ = 0.0;
-  pot_relative_encoder_offset_ = 0.0;
-  offset_ = 0.0;
-  samples_idx_ = 0;
-  filtered_position_ = 0.0;
-  position_ = 0.0;
-  zeroed_ = false;
-  nan_samples_ = 0;
-  relative_to_absolute_offset_samples_.clear();
-  offset_samples_.clear();
-  move_detector_.Reset();
-  error_ = false;
-}
-
-// So, this needs to be a multistep process.  We need to first estimate the
-// offset between the absolute encoder and the relative encoder.  That process
-// should get us an absolute number which is off by integer multiples of the
-// distance/rev.  In parallel, we can estimate the offset between the pot and
-// encoder.  When both estimates have converged, we can then compute the offset
-// in a cycle, and which cycle, which gives us the accurate global offset.
-//
-// It's tricky to compute the offset between the absolute and relative encoder.
-// We need to compute this inside 1 revolution.  The easiest way to do this
-// would be to wrap the encoder, subtract the two of them, and then average the
-// result.  That will struggle when they are off by PI.  Instead, we need to
-// wrap the number to +- PI from the current averaged offset.
-//
-// To guard against the robot moving while updating estimates, buffer a number
-// of samples and check that the buffered samples are not different than the
-// zeroing threshold. At any point that the samples differ too much, do not
-// update estimates based on those samples.
-void PotAndAbsoluteEncoderZeroingEstimator::UpdateEstimate(
-    const PotAndAbsolutePosition &info) {
-  // Check for Abs Encoder NaN value that would mess up the rest of the zeroing
-  // code below. NaN values are given when the Absolute Encoder is disconnected.
-  if (::std::isnan(info.absolute_encoder())) {
-    if (zeroed_) {
-      VLOG(1) << "NAN on absolute encoder.";
-      error_ = true;
-    } else {
-      ++nan_samples_;
-      VLOG(1) << "NAN on absolute encoder while zeroing" << nan_samples_;
-      if (nan_samples_ >= constants_.average_filter_size) {
-        error_ = true;
-        zeroed_ = true;
-      }
-    }
-    // Throw some dummy values in for now.
-    filtered_absolute_encoder_ = info.absolute_encoder();
-    filtered_position_ = pot_relative_encoder_offset_ + info.encoder();
-    position_ = offset_ + info.encoder();
-    return;
-  }
-
-  const bool moving = move_detector_.Update(info, constants_.moving_buffer_size,
-                                            constants_.zeroing_threshold);
-
-  if (!moving) {
-    const PositionStruct &sample = move_detector_.GetSample();
-
-    // Compute the average offset between the absolute encoder and relative
-    // encoder.  If we have 0 samples, assume it is 0.
-    double average_relative_to_absolute_offset =
-        relative_to_absolute_offset_samples_.size() == 0
-            ? 0.0
-            : ::std::accumulate(relative_to_absolute_offset_samples_.begin(),
-                                relative_to_absolute_offset_samples_.end(),
-                                0.0) /
-                  relative_to_absolute_offset_samples_.size();
-
-    const double adjusted_incremental_encoder =
-        sample.encoder + average_relative_to_absolute_offset;
-
-    // Now, compute the nearest absolute encoder value to the offset relative
-    // encoder position.
-    const double adjusted_absolute_encoder =
-        UnWrap(adjusted_incremental_encoder,
-               sample.absolute_encoder - constants_.measured_absolute_position,
-               constants_.one_revolution_distance);
-
-    // We can now compute the offset now that we have unwrapped the absolute
-    // encoder.
-    const double relative_to_absolute_offset =
-        adjusted_absolute_encoder - sample.encoder;
-
-    // Add the sample and update the average with the new reading.
-    const size_t relative_to_absolute_offset_samples_size =
-        relative_to_absolute_offset_samples_.size();
-    if (relative_to_absolute_offset_samples_size <
-        constants_.average_filter_size) {
-      average_relative_to_absolute_offset =
-          (average_relative_to_absolute_offset *
-               relative_to_absolute_offset_samples_size +
-           relative_to_absolute_offset) /
-          (relative_to_absolute_offset_samples_size + 1);
-
-      relative_to_absolute_offset_samples_.push_back(
-          relative_to_absolute_offset);
-    } else {
-      average_relative_to_absolute_offset -=
-          relative_to_absolute_offset_samples_[samples_idx_] /
-          relative_to_absolute_offset_samples_size;
-      relative_to_absolute_offset_samples_[samples_idx_] =
-          relative_to_absolute_offset;
-      average_relative_to_absolute_offset +=
-          relative_to_absolute_offset /
-          relative_to_absolute_offset_samples_size;
-    }
-
-    // Now compute the offset between the pot and relative encoder.
-    if (offset_samples_.size() < constants_.average_filter_size) {
-      offset_samples_.push_back(sample.pot - sample.encoder);
-    } else {
-      offset_samples_[samples_idx_] = sample.pot - sample.encoder;
-    }
-
-    // Drop the oldest sample when we run this function the next time around.
-    samples_idx_ = (samples_idx_ + 1) % constants_.average_filter_size;
-
-    pot_relative_encoder_offset_ =
-        ::std::accumulate(offset_samples_.begin(), offset_samples_.end(), 0.0) /
-        offset_samples_.size();
-
-    offset_ = UnWrap(sample.encoder + pot_relative_encoder_offset_,
-                     average_relative_to_absolute_offset + sample.encoder,
-                     constants_.one_revolution_distance) -
-              sample.encoder;
-
-    // Reverse the math for adjusted_absolute_encoder to compute the absolute
-    // encoder. Do this by taking the adjusted encoder, and then subtracting off
-    // the second argument above, and the value that was added by Wrap.
-    filtered_absolute_encoder_ =
-        ((sample.encoder + average_relative_to_absolute_offset) -
-         (-constants_.measured_absolute_position +
-          (adjusted_absolute_encoder -
-           (sample.absolute_encoder - constants_.measured_absolute_position))));
-
-    if (offset_ready()) {
-      if (!zeroed_) {
-        first_offset_ = offset_;
-      }
-
-      if (::std::abs(first_offset_ - offset_) >
-          constants_.allowable_encoder_error *
-              constants_.one_revolution_distance) {
-        VLOG(1) << "Offset moved too far. Initial: " << first_offset_
-                << ", current " << offset_ << ", allowable change: "
-                << constants_.allowable_encoder_error *
-                       constants_.one_revolution_distance;
-        error_ = true;
-      }
-
-      zeroed_ = true;
-    }
-  }
-
-  // Update the position.
-  filtered_position_ = pot_relative_encoder_offset_ + info.encoder();
-  position_ = offset_ + info.encoder();
-}
-
-flatbuffers::Offset<PotAndAbsoluteEncoderZeroingEstimator::State>
-PotAndAbsoluteEncoderZeroingEstimator::GetEstimatorState(
-    flatbuffers::FlatBufferBuilder *fbb) const {
-  State::Builder builder(*fbb);
-  builder.add_error(error_);
-  builder.add_zeroed(zeroed_);
-  builder.add_position(position_);
-  builder.add_pot_position(filtered_position_);
-  builder.add_absolute_position(filtered_absolute_encoder_);
-  return builder.Finish();
-}
-
-void PulseIndexZeroingEstimator::Reset() {
-  max_index_position_ = ::std::numeric_limits<double>::lowest();
-  min_index_position_ = ::std::numeric_limits<double>::max();
-  offset_ = 0;
-  last_used_index_pulse_count_ = 0;
-  zeroed_ = false;
-  error_ = false;
-}
-
-void PulseIndexZeroingEstimator::StoreIndexPulseMaxAndMin(
-    const IndexPosition &info) {
-  // If we have a new index pulse.
-  if (last_used_index_pulse_count_ != info.index_pulses()) {
-    // If the latest pulses's position is outside the range we've currently
-    // seen, record it appropriately.
-    if (info.latched_encoder() > max_index_position_) {
-      max_index_position_ = info.latched_encoder();
-    }
-    if (info.latched_encoder() < min_index_position_) {
-      min_index_position_ = info.latched_encoder();
-    }
-    last_used_index_pulse_count_ = info.index_pulses();
-  }
-}
-
-int PulseIndexZeroingEstimator::IndexPulseCount() const {
-  if (min_index_position_ > max_index_position_) {
-    // This condition means we haven't seen a pulse yet.
-    return 0;
-  }
-
-  // Calculate the number of pulses encountered so far.
-  return 1 + static_cast<int>(
-                 ::std::round((max_index_position_ - min_index_position_) /
-                              constants_.index_difference));
-}
-
-void PulseIndexZeroingEstimator::UpdateEstimate(const IndexPosition &info) {
-  StoreIndexPulseMaxAndMin(info);
-  const int index_pulse_count = IndexPulseCount();
-  if (index_pulse_count > constants_.index_pulse_count) {
-    if (!error_) {
-      VLOG(1) << "Got more index pulses than expected. Got "
-              << index_pulse_count << " expected "
-              << constants_.index_pulse_count;
-      error_ = true;
-    }
-  }
-
-  // TODO(austin): Detect if the encoder or index pulse is unplugged.
-  // TODO(austin): Detect missing counts.
-
-  if (index_pulse_count == constants_.index_pulse_count && !zeroed_) {
-    offset_ = constants_.measured_index_position -
-              constants_.known_index_pulse * constants_.index_difference -
-              min_index_position_;
-    zeroed_ = true;
-  } else if (zeroed_ && !error_) {
-    // Detect whether the index pulse is somewhere other than where we expect
-    // it to be. First we compute the position of the most recent index pulse.
-    double index_pulse_distance =
-        info.latched_encoder() + offset_ - constants_.measured_index_position;
-    // Second we compute the position of the index pulse in terms of
-    // the index difference. I.e. if this index pulse is two pulses away from
-    // the index pulse that we know about then this number should be positive
-    // or negative two.
-    double relative_distance =
-        index_pulse_distance / constants_.index_difference;
-    // Now we compute how far away the measured index pulse is from the
-    // expected index pulse.
-    double error = relative_distance - ::std::round(relative_distance);
-    // This lets us check if the index pulse is within an acceptable error
-    // margin of where we expected it to be.
-    if (::std::abs(error) > constants_.allowable_encoder_error) {
-      VLOG(1)
-          << "Encoder ticks out of range since last index pulse. known index "
-             "pulse: "
-          << constants_.measured_index_position << ", expected index pulse: "
-          << round(relative_distance) * constants_.index_difference +
-                 constants_.measured_index_position
-          << ", actual index pulse: " << info.latched_encoder() + offset_
-          << ", "
-             "allowable error: "
-          << constants_.allowable_encoder_error * constants_.index_difference;
-      error_ = true;
-    }
-  }
-
-  position_ = info.encoder() + offset_;
-}
-
-flatbuffers::Offset<PulseIndexZeroingEstimator::State>
-PulseIndexZeroingEstimator::GetEstimatorState(
-    flatbuffers::FlatBufferBuilder *fbb) const {
-  State::Builder builder(*fbb);
-  builder.add_error(error_);
-  builder.add_zeroed(zeroed_);
-  builder.add_position(position_);
-  builder.add_min_index_position(min_index_position_);
-  builder.add_max_index_position(max_index_position_);
-  builder.add_index_pulses_seen(IndexPulseCount());
-  return builder.Finish();
-}
-
-AbsoluteEncoderZeroingEstimator::AbsoluteEncoderZeroingEstimator(
-    const constants::AbsoluteEncoderZeroingConstants &constants)
-    : constants_(constants), move_detector_(constants_.moving_buffer_size) {
-  relative_to_absolute_offset_samples_.reserve(constants_.average_filter_size);
-  Reset();
-}
-
-void AbsoluteEncoderZeroingEstimator::Reset() {
-  zeroed_ = false;
-  error_ = false;
-  first_offset_ = 0.0;
-  offset_ = 0.0;
-  samples_idx_ = 0;
-  position_ = 0.0;
-  nan_samples_ = 0;
-  relative_to_absolute_offset_samples_.clear();
-  move_detector_.Reset();
-}
-
-
-// The math here is a bit backwards, but I think it'll be less error prone that
-// way and more similar to the version with a pot as well.
-//
-// We start by unwrapping the absolute encoder using the relative encoder.  This
-// puts us in a non-wrapping space and lets us average a bit easier.  From
-// there, we can compute an offset and wrap ourselves back such that we stay
-// close to the middle value.
-//
-// To guard against the robot moving while updating estimates, buffer a number
-// of samples and check that the buffered samples are not different than the
-// zeroing threshold. At any point that the samples differ too much, do not
-// update estimates based on those samples.
-void AbsoluteEncoderZeroingEstimator::UpdateEstimate(
-    const AbsolutePosition &info) {
-  // Check for Abs Encoder NaN value that would mess up the rest of the zeroing
-  // code below. NaN values are given when the Absolute Encoder is disconnected.
-  if (::std::isnan(info.absolute_encoder())) {
-    if (zeroed_) {
-      VLOG(1) << "NAN on absolute encoder.";
-      error_ = true;
-    } else {
-      ++nan_samples_;
-      VLOG(1) << "NAN on absolute encoder while zeroing " << nan_samples_;
-      if (nan_samples_ >= constants_.average_filter_size) {
-        error_ = true;
-        zeroed_ = true;
-      }
-    }
-    // Throw some dummy values in for now.
-    filtered_absolute_encoder_ = info.absolute_encoder();
-    position_ = offset_ + info.encoder();
-    return;
-  }
-
-  const bool moving = move_detector_.Update(info, constants_.moving_buffer_size,
-                                            constants_.zeroing_threshold);
-
-  if (!moving) {
-    const PositionStruct &sample = move_detector_.GetSample();
-
-    // Compute the average offset between the absolute encoder and relative
-    // encoder.  If we have 0 samples, assume it is 0.
-    double average_relative_to_absolute_offset =
-        relative_to_absolute_offset_samples_.size() == 0
-            ? 0.0
-            : ::std::accumulate(relative_to_absolute_offset_samples_.begin(),
-                                relative_to_absolute_offset_samples_.end(),
-                                0.0) /
-                  relative_to_absolute_offset_samples_.size();
-
-    // Now, compute the estimated absolute position using the previously
-    // estimated offset and the incremental encoder.
-    const double adjusted_incremental_encoder =
-        sample.encoder + average_relative_to_absolute_offset;
-
-    // Now, compute the absolute encoder value nearest to the offset relative
-    // encoder position.
-    const double adjusted_absolute_encoder =
-        UnWrap(adjusted_incremental_encoder,
-               sample.absolute_encoder - constants_.measured_absolute_position,
-               constants_.one_revolution_distance);
-
-    // We can now compute the offset now that we have unwrapped the absolute
-    // encoder.
-    const double relative_to_absolute_offset =
-        adjusted_absolute_encoder - sample.encoder;
-
-    // Add the sample and update the average with the new reading.
-    const size_t relative_to_absolute_offset_samples_size =
-        relative_to_absolute_offset_samples_.size();
-    if (relative_to_absolute_offset_samples_size <
-        constants_.average_filter_size) {
-      average_relative_to_absolute_offset =
-          (average_relative_to_absolute_offset *
-               relative_to_absolute_offset_samples_size +
-           relative_to_absolute_offset) /
-          (relative_to_absolute_offset_samples_size + 1);
-
-      relative_to_absolute_offset_samples_.push_back(
-          relative_to_absolute_offset);
-    } else {
-      average_relative_to_absolute_offset -=
-          relative_to_absolute_offset_samples_[samples_idx_] /
-          relative_to_absolute_offset_samples_size;
-      relative_to_absolute_offset_samples_[samples_idx_] =
-          relative_to_absolute_offset;
-      average_relative_to_absolute_offset +=
-          relative_to_absolute_offset /
-          relative_to_absolute_offset_samples_size;
-    }
-
-    // Drop the oldest sample when we run this function the next time around.
-    samples_idx_ = (samples_idx_ + 1) % constants_.average_filter_size;
-
-    // And our offset is the offset that gives us the position within +- ord/2
-    // of the middle position.
-    offset_ = Wrap(constants_.middle_position,
-                   average_relative_to_absolute_offset + sample.encoder,
-                   constants_.one_revolution_distance) -
-              sample.encoder;
-
-    // Reverse the math for adjusted_absolute_encoder to compute the absolute
-    // encoder. Do this by taking the adjusted encoder, and then subtracting off
-    // the second argument above, and the value that was added by Wrap.
-    filtered_absolute_encoder_ =
-        ((sample.encoder + average_relative_to_absolute_offset) -
-         (-constants_.measured_absolute_position +
-          (adjusted_absolute_encoder -
-           (sample.absolute_encoder - constants_.measured_absolute_position))));
-
-    if (offset_ready()) {
-      if (!zeroed_) {
-        first_offset_ = offset_;
-      }
-
-      if (::std::abs(first_offset_ - offset_) >
-          constants_.allowable_encoder_error *
-              constants_.one_revolution_distance) {
-        VLOG(1) << "Offset moved too far. Initial: " << first_offset_
-                << ", current " << offset_ << ", allowable change: "
-                << constants_.allowable_encoder_error *
-                       constants_.one_revolution_distance;
-        error_ = true;
-      }
-
-      zeroed_ = true;
-    }
-  }
-
-  // Update the position.
-  position_ = offset_ + info.encoder();
-}
-
-flatbuffers::Offset<AbsoluteEncoderZeroingEstimator::State>
-AbsoluteEncoderZeroingEstimator::GetEstimatorState(
-    flatbuffers::FlatBufferBuilder *fbb) const {
-  State::Builder builder(*fbb);
-  builder.add_error(error_);
-  builder.add_zeroed(zeroed_);
-  builder.add_position(position_);
-  builder.add_absolute_position(filtered_absolute_encoder_);
-  return builder.Finish();
-}
-
-}  // namespace zeroing
-}  // namespace frc971
diff --git a/frc971/zeroing/zeroing.h b/frc971/zeroing/zeroing.h
index fe1b461..4d0c1cc 100644
--- a/frc971/zeroing/zeroing.h
+++ b/frc971/zeroing/zeroing.h
@@ -58,169 +58,6 @@
       flatbuffers::FlatBufferBuilder *fbb) const = 0;
 };
 
-// Estimates the position with an incremental encoder with an index pulse and a
-// potentiometer.
-class PotAndIndexPulseZeroingEstimator
-    : public ZeroingEstimator<PotAndIndexPosition,
-                              constants::PotAndIndexPulseZeroingConstants,
-                              EstimatorState> {
- public:
-  explicit PotAndIndexPulseZeroingEstimator(
-      const constants::PotAndIndexPulseZeroingConstants &constants);
-
-  // Update the internal logic with the next sensor values.
-  void UpdateEstimate(const PotAndIndexPosition &info) override;
-
-  // Reset the internal logic so it needs to be re-zeroed.
-  void Reset() override;
-
-  // Manually trigger an internal error. This is used for testing the error
-  // logic.
-  void TriggerError() override;
-
-  bool error() const override { return error_; }
-
-  bool zeroed() const override { return zeroed_; }
-
-  double offset() const override { return offset_; }
-
-  // Returns a number between 0 and 1 that represents the percentage of the
-  // samples being used in the moving average filter. A value of 0.0 means that
-  // no samples are being used. A value of 1.0 means that the filter is using
-  // as many samples as it has room for. For example, after a Reset() this
-  // value returns 0.0. As more samples get added with UpdateEstimate(...) the
-  // return value starts increasing to 1.0.
-  double offset_ratio_ready() const {
-    return start_pos_samples_.size() /
-           static_cast<double>(constants_.average_filter_size);
-  }
-
-  // Returns true if the sample buffer is full.
-  bool offset_ready() const override {
-    return start_pos_samples_.size() == constants_.average_filter_size;
-  }
-
-  // Returns information about our current state.
-  virtual flatbuffers::Offset<State> GetEstimatorState(
-      flatbuffers::FlatBufferBuilder *fbb) const override;
-
- private:
-  // This function calculates the start position given the internal state and
-  // the provided `latched_encoder' value.
-  double CalculateStartPosition(double start_average,
-                                double latched_encoder) const;
-
-  // The zeroing constants used to describe the configuration of the system.
-  const constants::PotAndIndexPulseZeroingConstants constants_;
-
-  // The estimated position.
-  double position_;
-  // The unzeroed filtered position.
-  double filtered_position_ = 0.0;
-  // The next position in 'start_pos_samples_' to be used to store the next
-  // sample.
-  int samples_idx_;
-  // Last 'max_sample_count_' samples for start positions.
-  std::vector<double> start_pos_samples_;
-  // The estimated starting position of the mechanism. We also call this the
-  // 'offset' in some contexts.
-  double offset_;
-  // Flag for triggering logic that takes note of the current index pulse count
-  // after a reset. See `last_used_index_pulse_count_'.
-  bool wait_for_index_pulse_;
-  // After a reset we keep track of the index pulse count with this. Only after
-  // the index pulse count changes (i.e. increments at least once or wraps
-  // around) will we consider the mechanism zeroed. We also use this to store
-  // the most recent `PotAndIndexPosition::index_pulses' value when the start
-  // position was calculated. It helps us calculate the start position only on
-  // index pulses to reject corrupted intermediate data.
-  uint32_t last_used_index_pulse_count_;
-  // Marker to track whether we're fully zeroed yet or not.
-  bool zeroed_;
-  // Marker to track whether an error has occurred. This gets reset to false
-  // whenever Reset() is called.
-  bool error_;
-  // Stores the position "start_pos" variable the first time the program
-  // is zeroed.
-  double first_start_pos_;
-};
-
-// Estimates the position with an incremental encoder and a hall effect sensor.
-class HallEffectAndPositionZeroingEstimator
-    : public ZeroingEstimator<HallEffectAndPosition,
-                              constants::HallEffectZeroingConstants,
-                              HallEffectAndPositionEstimatorState> {
- public:
-  explicit HallEffectAndPositionZeroingEstimator(
-      const ZeroingConstants &constants);
-
-  // Update the internal logic with the next sensor values.
-  void UpdateEstimate(const Position &info) override;
-
-  // Reset the internal logic so it needs to be re-zeroed.
-  void Reset() override;
-
-  // Manually trigger an internal error. This is used for testing the error
-  // logic.
-  void TriggerError() override;
-
-  bool error() const override { return error_; }
-
-  bool zeroed() const override { return zeroed_; }
-
-  double offset() const override { return offset_; }
-
-  bool offset_ready() const override { return zeroed_; }
-
-  // Returns information about our current state.
-  virtual flatbuffers::Offset<State> GetEstimatorState(
-      flatbuffers::FlatBufferBuilder *fbb) const override;
-
- private:
-  // Sets the minimum and maximum posedge position values.
-  void StoreEncoderMaxAndMin(const HallEffectAndPosition &info);
-
-  // The zeroing constants used to describe the configuration of the system.
-  const ZeroingConstants constants_;
-
-  // The estimated state of the hall effect.
-  double current_ = 0.0;
-  // The estimated position.
-  double position_ = 0.0;
-  // The smallest and largest positions of the last set of encoder positions
-  // while the hall effect was low.
-  double min_low_position_;
-  double max_low_position_;
-  // If we've seen the hall effect high for enough times without going low, then
-  // we can be sure it isn't a false positive.
-  bool high_long_enough_;
-  size_t cycles_high_;
-
-  bool last_hall_ = false;
-
-  // The estimated starting position of the mechanism. We also call this the
-  // 'offset' in some contexts.
-  double offset_;
-  // Flag for triggering logic that takes note of the current posedge count
-  // after a reset. See `last_used_posedge_count_'.
-  bool initialized_;
-  // After a reset we keep track of the posedge count with this. Only after the
-  // posedge count changes (i.e. increments at least once or wraps around) will
-  // we consider the mechanism zeroed. We also use this to store the most recent
-  // `HallEffectAndPosition::posedge_count' value when the start position
-  // was calculated. It helps us calculate the start position only on posedges
-  // to reject corrupted intermediate data.
-  int32_t last_used_posedge_count_;
-  // Marker to track whether we're fully zeroed yet or not.
-  bool zeroed_;
-  // Marker to track whether an error has occurred. This gets reset to false
-  // whenever Reset() is called.
-  bool error_ = false;
-  // Stores the position "start_pos" variable the first time the program
-  // is zeroed.
-  double first_start_pos_;
-};
-
 // Class to encapsulate the logic to decide when we are moving and which samples
 // are safe to use.
 template <typename Position, typename PositionBuffer>
@@ -287,237 +124,7 @@
   size_t buffered_samples_idx_;
 };
 
-// Estimates the position with an absolute encoder which also reports
-// incremental counts, and a potentiometer.
-class PotAndAbsoluteEncoderZeroingEstimator
-    : public ZeroingEstimator<PotAndAbsolutePosition,
-                              constants::PotAndAbsoluteEncoderZeroingConstants,
-                              PotAndAbsoluteEncoderEstimatorState> {
- public:
-  explicit PotAndAbsoluteEncoderZeroingEstimator(
-      const constants::PotAndAbsoluteEncoderZeroingConstants &constants);
-
-  // Resets the internal logic so it needs to be re-zeroed.
-  void Reset() override;
-
-  // Updates the sensor values for the zeroing logic.
-  void UpdateEstimate(const PotAndAbsolutePosition &info) override;
-
-  void TriggerError() override { error_ = true; }
-
-  bool zeroed() const override { return zeroed_; }
-
-  double offset() const override { return offset_; }
-
-  bool error() const override { return error_; }
-
-  // Returns true if the sample buffer is full.
-  bool offset_ready() const override {
-    return relative_to_absolute_offset_samples_.size() ==
-               constants_.average_filter_size &&
-           offset_samples_.size() == constants_.average_filter_size;
-  }
-
-  // Returns information about our current state.
-  virtual flatbuffers::Offset<State> GetEstimatorState(
-      flatbuffers::FlatBufferBuilder *fbb) const override;
-
- private:
-  struct PositionStruct {
-    PositionStruct(const PotAndAbsolutePosition &position_buffer)
-        : absolute_encoder(position_buffer.absolute_encoder()),
-          encoder(position_buffer.encoder()),
-          pot(position_buffer.pot()) {}
-    double absolute_encoder;
-    double encoder;
-    double pot;
-  };
-
-  // The zeroing constants used to describe the configuration of the system.
-  const constants::PotAndAbsoluteEncoderZeroingConstants constants_;
-
-  // True if the mechanism is zeroed.
-  bool zeroed_;
-  // Marker to track whether an error has occurred.
-  bool error_;
-  // The first valid offset we recorded. This is only set after zeroed_ first
-  // changes to true.
-  double first_offset_;
-
-  // The filtered absolute encoder.  This is used in the status for calibration.
-  double filtered_absolute_encoder_ = 0.0;
-
-  // Samples of the offset needed to line the relative encoder up with the
-  // absolute encoder.
-  ::std::vector<double> relative_to_absolute_offset_samples_;
-  // Offset between the Pot and Relative encoder position.
-  ::std::vector<double> offset_samples_;
-
-  MoveDetector<PositionStruct, PotAndAbsolutePosition> move_detector_;
-
-  // Estimated offset between the pot and relative encoder.
-  double pot_relative_encoder_offset_ = 0;
-  // Estimated start position of the mechanism
-  double offset_ = 0;
-  // The next position in 'relative_to_absolute_offset_samples_' and
-  // 'encoder_samples_' to be used to store the next sample.
-  int samples_idx_ = 0;
-
-  size_t nan_samples_ = 0;
-
-  // The unzeroed filtered position.
-  double filtered_position_ = 0.0;
-  // The filtered position.
-  double position_ = 0.0;
-};
-
-// Zeros by seeing all the index pulses in the range of motion of the mechanism
-// and using that to figure out which index pulse is which.
-class PulseIndexZeroingEstimator
-    : public ZeroingEstimator<IndexPosition,
-                              constants::EncoderPlusIndexZeroingConstants,
-                              IndexEstimatorState> {
- public:
-  explicit PulseIndexZeroingEstimator(const ZeroingConstants &constants)
-      : constants_(constants) {
-    Reset();
-  }
-
-  // Resets the internal logic so it needs to be re-zeroed.
-  void Reset() override;
-
-  bool zeroed() const override { return zeroed_; }
-
-  // It's as ready as it'll ever be...
-  bool offset_ready() const override { return true; }
-
-  double offset() const override { return offset_; }
-
-  bool error() const override { return error_; }
-
-  // Updates the internal logic with the next sensor values.
-  void UpdateEstimate(const IndexPosition &info) override;
-
-  // Returns information about our current state.
-  virtual flatbuffers::Offset<State> GetEstimatorState(
-      flatbuffers::FlatBufferBuilder *fbb) const override;
-
-  void TriggerError() override { error_ = true; }
-
- private:
-  // Returns the current real position using the relative encoder offset.
-  double CalculateCurrentPosition(const IndexPosition &info);
-
-  // Sets the minimum and maximum index pulse position values.
-  void StoreIndexPulseMaxAndMin(const IndexPosition &info);
-
-  // Returns the number of index pulses we should have seen so far.
-  int IndexPulseCount() const;
-
-  // Contains the physical constants describing the system.
-  const ZeroingConstants constants_;
-
-  // The smallest position of all the index pulses.
-  double min_index_position_;
-  // The largest position of all the index pulses.
-  double max_index_position_;
-
-  // The estimated starting position of the mechanism.
-  double offset_;
-  // After a reset we keep track of the index pulse count with this. Only after
-  // the index pulse count changes (i.e. increments at least once or wraps
-  // around) will we consider the mechanism zeroed. We also use this to store
-  // the most recent `PotAndIndexPosition::index_pulses' value when the start
-  // position was calculated. It helps us calculate the start position only on
-  // index pulses to reject corrupted intermediate data.
-  uint32_t last_used_index_pulse_count_;
-
-  // True if we are fully zeroed.
-  bool zeroed_;
-  // Marker to track whether an error has occurred.
-  bool error_;
-
-  // The estimated position.
-  double position_;
-};
-
-// Estimates the position with an absolute encoder which also reports
-// incremental counts.  The absolute encoder can't spin more than one
-// revolution.
-class AbsoluteEncoderZeroingEstimator
-    : public ZeroingEstimator<AbsolutePosition,
-                              constants::AbsoluteEncoderZeroingConstants,
-                              AbsoluteEncoderEstimatorState> {
- public:
-  explicit AbsoluteEncoderZeroingEstimator(
-      const constants::AbsoluteEncoderZeroingConstants &constants);
-
-  // Resets the internal logic so it needs to be re-zeroed.
-  void Reset() override;
-
-  // Updates the sensor values for the zeroing logic.
-  void UpdateEstimate(const AbsolutePosition &info) override;
-
-  void TriggerError() override { error_ = true; }
-
-  bool zeroed() const override { return zeroed_; }
-
-  double offset() const override { return offset_; }
-
-  bool error() const override { return error_; }
-
-  // Returns true if the sample buffer is full.
-  bool offset_ready() const override {
-    return relative_to_absolute_offset_samples_.size() ==
-           constants_.average_filter_size;
-  }
-
-  // Returns information about our current state.
-  virtual flatbuffers::Offset<State> GetEstimatorState(
-      flatbuffers::FlatBufferBuilder *fbb) const override;
-
- private:
-  struct PositionStruct {
-    PositionStruct(const AbsolutePosition &position_buffer)
-        : absolute_encoder(position_buffer.absolute_encoder()),
-          encoder(position_buffer.encoder()) {}
-    double absolute_encoder;
-    double encoder;
-  };
-
-  // The zeroing constants used to describe the configuration of the system.
-  const constants::AbsoluteEncoderZeroingConstants constants_;
-
-  // True if the mechanism is zeroed.
-  bool zeroed_;
-  // Marker to track whether an error has occurred.
-  bool error_;
-  // The first valid offset we recorded. This is only set after zeroed_ first
-  // changes to true.
-  double first_offset_;
-
-  // The filtered absolute encoder.  This is used in the status for calibration.
-  double filtered_absolute_encoder_ = 0.0;
-
-  // Samples of the offset needed to line the relative encoder up with the
-  // absolute encoder.
-  ::std::vector<double> relative_to_absolute_offset_samples_;
-
-  MoveDetector<PositionStruct, AbsolutePosition> move_detector_;
-
-  // Estimated start position of the mechanism
-  double offset_ = 0;
-  // The next position in 'relative_to_absolute_offset_samples_' and
-  // 'encoder_samples_' to be used to store the next sample.
-  int samples_idx_ = 0;
-
-  // Number of NANs we've seen in a row.
-  size_t nan_samples_ = 0;
-
-  // The filtered position.
-  double position_ = 0.0;
-};
-
+// A trivial ZeroingEstimator which just passes the position straight through.
 class RelativeEncoderZeroingEstimator
     : public ZeroingEstimator<RelativePosition, void,
                               RelativeEncoderEstimatorState> {
@@ -562,4 +169,12 @@
 }  // namespace zeroing
 }  // namespace frc971
 
+// TODO(Brian): Actually split these targets apart. Need to convert all the
+// reverse dependencies to #include what they actually need...
+#include "frc971/zeroing/absolute_encoder.h"
+#include "frc971/zeroing/hall_effect_and_position.h"
+#include "frc971/zeroing/pot_and_absolute_encoder.h"
+#include "frc971/zeroing/pot_and_index.h"
+#include "frc971/zeroing/pulse_index.h"
+
 #endif  // FRC971_ZEROING_ZEROING_H_
diff --git a/frc971/zeroing/zeroing_test.cc b/frc971/zeroing/zeroing_test.cc
deleted file mode 100644
index 2b715ea..0000000
--- a/frc971/zeroing/zeroing_test.cc
+++ /dev/null
@@ -1,817 +0,0 @@
-#include "frc971/zeroing/zeroing.h"
-
-#include <unistd.h>
-
-#include <memory>
-#include <random>
-
-#include "aos/die.h"
-#include "frc971/control_loops/control_loops_generated.h"
-#include "frc971/control_loops/position_sensor_sim.h"
-#include "gtest/gtest.h"
-
-namespace frc971 {
-namespace zeroing {
-
-using constants::AbsoluteEncoderZeroingConstants;
-using constants::EncoderPlusIndexZeroingConstants;
-using constants::PotAndAbsoluteEncoderZeroingConstants;
-using constants::PotAndIndexPulseZeroingConstants;
-using control_loops::PositionSensorSimulator;
-using FBB = flatbuffers::FlatBufferBuilder;
-
-static const size_t kSampleSize = 30;
-static const double kAcceptableUnzeroedError = 0.2;
-static const double kIndexErrorFraction = 0.3;
-static const size_t kMovingBufferSize = 3;
-
-class ZeroingTest : public ::testing::Test {
- protected:
-  void SetUp() override {}
-
-  void MoveTo(PositionSensorSimulator *simulator,
-              PotAndIndexPulseZeroingEstimator *estimator,
-              double new_position) {
-    simulator->MoveTo(new_position);
-    FBB fbb;
-    estimator->UpdateEstimate(
-        *simulator->FillSensorValues<PotAndIndexPosition>(&fbb));
-  }
-
-  void MoveTo(PositionSensorSimulator *simulator,
-              AbsoluteEncoderZeroingEstimator *estimator, double new_position) {
-    simulator->MoveTo(new_position);
-    FBB fbb;
-    estimator->UpdateEstimate(
-        *simulator->FillSensorValues<AbsolutePosition>(&fbb));
-  }
-
-  void MoveTo(PositionSensorSimulator *simulator,
-              PotAndAbsoluteEncoderZeroingEstimator *estimator,
-              double new_position) {
-    simulator->MoveTo(new_position);
-    FBB fbb;
-    estimator->UpdateEstimate(
-        *simulator->FillSensorValues<PotAndAbsolutePosition>(&fbb));
-  }
-
-  void MoveTo(PositionSensorSimulator *simulator,
-              PulseIndexZeroingEstimator *estimator, double new_position) {
-    simulator->MoveTo(new_position);
-    FBB fbb;
-    estimator->UpdateEstimate(
-        *simulator->FillSensorValues<IndexPosition>(&fbb));
-  }
-
-  void MoveTo(PositionSensorSimulator *simulator,
-              HallEffectAndPositionZeroingEstimator *estimator,
-              double new_position) {
-    simulator->MoveTo(new_position);
-    FBB fbb;
-    estimator->UpdateEstimate(
-        *simulator->FillSensorValues<HallEffectAndPosition>(&fbb));
-  }
-
-  void MoveTo(PositionSensorSimulator *simulator,
-              RelativeEncoderZeroingEstimator *estimator, double new_position) {
-    simulator->MoveTo(new_position);
-    FBB fbb;
-    estimator->UpdateEstimate(
-        *simulator->FillSensorValues<RelativePosition>(&fbb));
-  }
-
-  template <typename T>
-  double GetEstimatorPosition(T *estimator) {
-    FBB fbb;
-    fbb.Finish(estimator->GetEstimatorState(&fbb));
-    return flatbuffers::GetRoot<typename T::State>(fbb.GetBufferPointer())
-        ->position();
-  }
-};
-
-TEST_F(ZeroingTest, TestMovingAverageFilter) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.6 * index_diff, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  // The zeroing code is supposed to perform some filtering on the difference
-  // between the potentiometer value and the encoder value. We assume that 300
-  // samples are sufficient to have updated the filter.
-  for (int i = 0; i < 300; i++) {
-    MoveTo(&sim, &estimator, 3.3 * index_diff);
-  }
-  ASSERT_NEAR(3.3 * index_diff, GetEstimatorPosition(&estimator),
-              kAcceptableUnzeroedError * index_diff);
-
-  for (int i = 0; i < 300; i++) {
-    MoveTo(&sim, &estimator, 3.9 * index_diff);
-  }
-  ASSERT_NEAR(3.9 * index_diff, GetEstimatorPosition(&estimator),
-              kAcceptableUnzeroedError * index_diff);
-}
-
-TEST_F(ZeroingTest, NotZeroedBeforeEnoughSamplesCollected) {
-  double index_diff = 0.5;
-  double position = 3.6 * index_diff;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(position, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  // Make sure that the zeroing code does not consider itself zeroed until we
-  // collect a good amount of samples. In this case we're waiting until the
-  // moving average filter is full.
-  for (unsigned int i = 0; i < kSampleSize - 1; i++) {
-    MoveTo(&sim, &estimator, position += index_diff);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  MoveTo(&sim, &estimator, position);
-  ASSERT_TRUE(estimator.zeroed());
-}
-
-TEST_F(ZeroingTest, TestLotsOfMovement) {
-  double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.6, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  // The zeroing code is supposed to perform some filtering on the difference
-  // between the potentiometer value and the encoder value. We assume that 300
-  // samples are sufficient to have updated the filter.
-  for (int i = 0; i < 300; i++) {
-    MoveTo(&sim, &estimator, 3.6);
-  }
-  ASSERT_NEAR(3.6, GetEstimatorPosition(&estimator),
-              kAcceptableUnzeroedError * index_diff);
-
-  // With a single index pulse the zeroing estimator should be able to lock
-  // onto the true value of the position.
-  MoveTo(&sim, &estimator, 4.01);
-  ASSERT_NEAR(4.01, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 4.99);
-  ASSERT_NEAR(4.99, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 3.99);
-  ASSERT_NEAR(3.99, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 3.01);
-  ASSERT_NEAR(3.01, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 13.55);
-  ASSERT_NEAR(13.55, GetEstimatorPosition(&estimator), 0.001);
-}
-
-TEST_F(ZeroingTest, TestDifferentIndexDiffs) {
-  double index_diff = 0.89;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.5 * index_diff, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  // The zeroing code is supposed to perform some filtering on the difference
-  // between the potentiometer value and the encoder value. We assume that 300
-  // samples are sufficient to have updated the filter.
-  for (int i = 0; i < 300; i++) {
-    MoveTo(&sim, &estimator, 3.5 * index_diff);
-  }
-  ASSERT_NEAR(3.5 * index_diff, GetEstimatorPosition(&estimator),
-              kAcceptableUnzeroedError * index_diff);
-
-  // With a single index pulse the zeroing estimator should be able to lock
-  // onto the true value of the position.
-  MoveTo(&sim, &estimator, 4.01);
-  ASSERT_NEAR(4.01, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 4.99);
-  ASSERT_NEAR(4.99, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 3.99);
-  ASSERT_NEAR(3.99, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 3.01);
-  ASSERT_NEAR(3.01, GetEstimatorPosition(&estimator), 0.001);
-
-  MoveTo(&sim, &estimator, 13.55);
-  ASSERT_NEAR(13.55, GetEstimatorPosition(&estimator), 0.001);
-}
-
-TEST_F(ZeroingTest, TestPercentage) {
-  double index_diff = 0.89;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.5 * index_diff, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  for (unsigned int i = 0; i < kSampleSize / 2; i++) {
-    MoveTo(&sim, &estimator, 3.5 * index_diff);
-  }
-  ASSERT_NEAR(0.5, estimator.offset_ratio_ready(), 0.001);
-  ASSERT_FALSE(estimator.offset_ready());
-
-  for (unsigned int i = 0; i < kSampleSize / 2; i++) {
-    MoveTo(&sim, &estimator, 3.5 * index_diff);
-  }
-  ASSERT_NEAR(1.0, estimator.offset_ratio_ready(), 0.001);
-  ASSERT_TRUE(estimator.offset_ready());
-}
-
-TEST_F(ZeroingTest, TestOffset) {
-  double index_diff = 0.89;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.1 * index_diff, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  MoveTo(&sim, &estimator, 3.1 * index_diff);
-
-  for (unsigned int i = 0; i < kSampleSize; i++) {
-    MoveTo(&sim, &estimator, 5.0 * index_diff);
-  }
-
-  ASSERT_NEAR(3.1 * index_diff, estimator.offset(), 0.001);
-}
-
-TEST_F(ZeroingTest, WaitForIndexPulseAfterReset) {
-  double index_diff = 0.6;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.1 * index_diff, index_diff / 3.0);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-
-  // Make sure to fill up the averaging filter with samples.
-  for (unsigned int i = 0; i < kSampleSize; i++) {
-    MoveTo(&sim, &estimator, 3.1 * index_diff);
-  }
-
-  // Make sure we're not zeroed until we hit an index pulse.
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Trigger an index pulse; we should now be zeroed.
-  MoveTo(&sim, &estimator, 4.5 * index_diff);
-  ASSERT_TRUE(estimator.zeroed());
-
-  // Reset the zeroing logic and supply a bunch of samples within the current
-  // index segment.
-  estimator.Reset();
-  for (unsigned int i = 0; i < kSampleSize; i++) {
-    MoveTo(&sim, &estimator, 4.2 * index_diff);
-  }
-
-  // Make sure we're not zeroed until we hit an index pulse.
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Trigger another index pulse; we should be zeroed again.
-  MoveTo(&sim, &estimator, 3.1 * index_diff);
-  ASSERT_TRUE(estimator.zeroed());
-}
-
-TEST_F(ZeroingTest, TestNonZeroIndexPulseOffsets) {
-  const double index_diff = 0.9;
-  const double known_index_pos = 3.5 * index_diff;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(3.3 * index_diff, index_diff / 3.0, known_index_pos);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, known_index_pos, kIndexErrorFraction});
-
-  // Make sure to fill up the averaging filter with samples.
-  for (unsigned int i = 0; i < kSampleSize; i++) {
-    MoveTo(&sim, &estimator, 3.3 * index_diff);
-  }
-
-  // Make sure we're not zeroed until we hit an index pulse.
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Trigger an index pulse; we should now be zeroed.
-  MoveTo(&sim, &estimator, 3.7 * index_diff);
-  ASSERT_TRUE(estimator.zeroed());
-  ASSERT_DOUBLE_EQ(3.3 * index_diff, estimator.offset());
-  ASSERT_DOUBLE_EQ(3.7 * index_diff, GetEstimatorPosition(&estimator));
-
-  // Trigger one more index pulse and check the offset.
-  MoveTo(&sim, &estimator, 4.7 * index_diff);
-  ASSERT_DOUBLE_EQ(3.3 * index_diff, estimator.offset());
-  ASSERT_DOUBLE_EQ(4.7 * index_diff, GetEstimatorPosition(&estimator));
-}
-
-TEST_F(ZeroingTest, BasicErrorAPITest) {
-  const double index_diff = 1.0;
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      kSampleSize, index_diff, 0.0, kIndexErrorFraction});
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(1.5 * index_diff, index_diff / 3.0, 0.0);
-
-  // Perform a simple move and make sure that no error occured.
-  MoveTo(&sim, &estimator, 3.5 * index_diff);
-  ASSERT_FALSE(estimator.error());
-
-  // Trigger an error and make sure it's reported.
-  estimator.TriggerError();
-  ASSERT_TRUE(estimator.error());
-
-  // Make sure that it can recover after a reset.
-  estimator.Reset();
-  ASSERT_FALSE(estimator.error());
-  MoveTo(&sim, &estimator, 4.5 * index_diff);
-  MoveTo(&sim, &estimator, 5.5 * index_diff);
-  ASSERT_FALSE(estimator.error());
-}
-
-// Tests that an error is detected when the starting position changes too much.
-TEST_F(ZeroingTest, TestIndexOffsetError) {
-  const double index_diff = 0.8;
-  const double known_index_pos = 2 * index_diff;
-  const size_t sample_size = 30;
-  PositionSensorSimulator sim(index_diff);
-  sim.Initialize(10 * index_diff, index_diff / 3.0, known_index_pos);
-  PotAndIndexPulseZeroingEstimator estimator(PotAndIndexPulseZeroingConstants{
-      sample_size, index_diff, known_index_pos, kIndexErrorFraction});
-
-  for (size_t i = 0; i < sample_size; i++) {
-    MoveTo(&sim, &estimator, 13 * index_diff);
-  }
-  MoveTo(&sim, &estimator, 8 * index_diff);
-
-  ASSERT_TRUE(estimator.zeroed());
-  ASSERT_FALSE(estimator.error());
-  sim.Initialize(9.0 * index_diff + 0.31 * index_diff, index_diff / 3.0,
-                 known_index_pos);
-  MoveTo(&sim, &estimator, 9 * index_diff);
-  ASSERT_TRUE(estimator.zeroed());
-  ASSERT_TRUE(estimator.error());
-}
-
-// Makes sure that using an absolute encoder lets us zero without moving.
-TEST_F(ZeroingTest, TestPotAndAbsoluteEncoderZeroingWithoutMovement) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-
-  const double start_pos = 2.1;
-  double measured_absolute_position = 0.3 * index_diff;
-
-  PotAndAbsoluteEncoderZeroingConstants constants{
-      kSampleSize, index_diff,        measured_absolute_position,
-      0.1,         kMovingBufferSize, kIndexErrorFraction};
-
-  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
-                 constants.measured_absolute_position);
-
-  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
-
-  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
-    MoveTo(&sim, &estimator, start_pos);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  MoveTo(&sim, &estimator, start_pos);
-  ASSERT_TRUE(estimator.zeroed());
-  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
-}
-
-// Makes sure that we ignore a NAN if we get it, but will correctly zero
-// afterwards.
-TEST_F(ZeroingTest, TestPotAndAbsoluteEncoderZeroingIgnoresNAN) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-
-  const double start_pos = 2.1;
-  double measured_absolute_position = 0.3 * index_diff;
-
-  PotAndAbsoluteEncoderZeroingConstants constants{
-      kSampleSize, index_diff,        measured_absolute_position,
-      0.1,         kMovingBufferSize, kIndexErrorFraction};
-
-  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
-                 constants.measured_absolute_position);
-
-  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
-
-  // We tolerate a couple NANs before we start.
-  FBB fbb;
-  fbb.Finish(CreatePotAndAbsolutePosition(
-      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN(), 0.0));
-  for (size_t i = 0; i < kSampleSize - 1; ++i) {
-    estimator.UpdateEstimate(
-        *flatbuffers::GetRoot<PotAndAbsolutePosition>(fbb.GetBufferPointer()));
-  }
-
-  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
-    MoveTo(&sim, &estimator, start_pos);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  MoveTo(&sim, &estimator, start_pos);
-  ASSERT_TRUE(estimator.zeroed());
-  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
-}
-
-// Makes sure that using an absolute encoder doesn't let us zero while moving.
-TEST_F(ZeroingTest, TestPotAndAbsoluteEncoderZeroingWithMovement) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-
-  const double start_pos = 10 * index_diff;
-  double measured_absolute_position = 0.3 * index_diff;
-
-  PotAndAbsoluteEncoderZeroingConstants constants{
-      kSampleSize, index_diff,        measured_absolute_position,
-      0.1,         kMovingBufferSize, kIndexErrorFraction};
-
-  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
-                 constants.measured_absolute_position);
-
-  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
-
-  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
-    MoveTo(&sim, &estimator, start_pos + i * index_diff);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-  MoveTo(&sim, &estimator, start_pos + 10 * index_diff);
-
-  MoveTo(&sim, &estimator, start_pos);
-  ASSERT_FALSE(estimator.zeroed());
-}
-
-// Makes sure we detect an error if the ZeroingEstimator gets sent a NaN.
-TEST_F(ZeroingTest, TestPotAndAbsoluteEncoderZeroingWithNaN) {
-  PotAndAbsoluteEncoderZeroingConstants constants{
-      kSampleSize, 1, 0.3, 0.1, kMovingBufferSize, kIndexErrorFraction};
-
-  PotAndAbsoluteEncoderZeroingEstimator estimator(constants);
-
-  FBB fbb;
-  fbb.Finish(CreatePotAndAbsolutePosition(
-      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN(), 0.0));
-  const auto sensor_values =
-      flatbuffers::GetRoot<PotAndAbsolutePosition>(fbb.GetBufferPointer());
-  for (size_t i = 0; i < kSampleSize - 1; ++i) {
-    estimator.UpdateEstimate(*sensor_values);
-  }
-  ASSERT_FALSE(estimator.error());
-
-  estimator.UpdateEstimate(*sensor_values);
-  ASSERT_TRUE(estimator.error());
-}
-
-// Tests that an error is detected when the starting position changes too much.
-TEST_F(ZeroingTest, TestRelativeEncoderZeroing) {
-  EncoderPlusIndexZeroingConstants constants;
-  constants.index_pulse_count = 3;
-  constants.index_difference = 10.0;
-  constants.measured_index_position = 20.0;
-  constants.known_index_pulse = 1;
-  constants.allowable_encoder_error = 0.01;
-
-  PositionSensorSimulator sim(constants.index_difference);
-
-  const double start_pos = 2.5 * constants.index_difference;
-
-  sim.Initialize(start_pos, constants.index_difference / 3.0,
-                 constants.measured_index_position);
-
-  PulseIndexZeroingEstimator estimator(constants);
-
-  // Should not be zeroed when we stand still.
-  for (int i = 0; i < 300; ++i) {
-    MoveTo(&sim, &estimator, start_pos);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  // Move to 1.5 constants.index_difference and we should still not be zeroed.
-  MoveTo(&sim, &estimator, 1.5 * constants.index_difference);
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Move to 0.5 constants.index_difference and we should still not be zeroed.
-  MoveTo(&sim, &estimator, 0.5 * constants.index_difference);
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Move back to 1.5 constants.index_difference and we should still not be
-  // zeroed.
-  MoveTo(&sim, &estimator, 1.5 * constants.index_difference);
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Move back to 2.5 constants.index_difference and we should still not be
-  // zeroed.
-  MoveTo(&sim, &estimator, 2.5 * constants.index_difference);
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Move back to 3.5 constants.index_difference and we should now be zeroed.
-  MoveTo(&sim, &estimator, 3.5 * constants.index_difference);
-  ASSERT_TRUE(estimator.zeroed());
-
-  ASSERT_DOUBLE_EQ(start_pos, estimator.offset());
-  ASSERT_DOUBLE_EQ(3.5 * constants.index_difference,
-                   GetEstimatorPosition(&estimator));
-
-  MoveTo(&sim, &estimator, 0.5 * constants.index_difference);
-  ASSERT_DOUBLE_EQ(0.5 * constants.index_difference,
-                   GetEstimatorPosition(&estimator));
-}
-
-// Tests that we can detect when an index pulse occurs where we didn't expect
-// it to for the PulseIndexZeroingEstimator.
-TEST_F(ZeroingTest, TestRelativeEncoderSlipping) {
-  EncoderPlusIndexZeroingConstants constants;
-  constants.index_pulse_count = 3;
-  constants.index_difference = 10.0;
-  constants.measured_index_position = 20.0;
-  constants.known_index_pulse = 1;
-  constants.allowable_encoder_error = 0.05;
-
-  PositionSensorSimulator sim(constants.index_difference);
-
-  const double start_pos =
-      constants.measured_index_position + 0.5 * constants.index_difference;
-
-  for (double direction : {1.0, -1.0}) {
-    sim.Initialize(start_pos, constants.index_difference / 3.0,
-                   constants.measured_index_position);
-
-    PulseIndexZeroingEstimator estimator(constants);
-
-    // Zero the estimator.
-    MoveTo(&sim, &estimator, start_pos - 1 * constants.index_difference);
-    MoveTo(
-        &sim, &estimator,
-        start_pos - constants.index_pulse_count * constants.index_difference);
-    ASSERT_TRUE(estimator.zeroed());
-    ASSERT_FALSE(estimator.error());
-
-    // We have a 5% allowable error so we slip a little bit each time and make
-    // sure that the index pulses are still accepted.
-    for (double error = 0.00;
-         ::std::abs(error) < constants.allowable_encoder_error;
-         error += 0.01 * direction) {
-      sim.Initialize(start_pos, constants.index_difference / 3.0,
-                     constants.measured_index_position +
-                         error * constants.index_difference);
-      MoveTo(&sim, &estimator, start_pos - constants.index_difference);
-      EXPECT_FALSE(estimator.error());
-    }
-
-    // As soon as we hit cross the error margin, we should trigger an error.
-    sim.Initialize(start_pos, constants.index_difference / 3.0,
-                   constants.measured_index_position +
-                       constants.allowable_encoder_error * 1.1 *
-                           constants.index_difference * direction);
-    MoveTo(&sim, &estimator, start_pos - constants.index_difference);
-    ASSERT_TRUE(estimator.error());
-  }
-}
-
-// Test fixture for HallEffectAndPositionZeroingEstimator.
-class HallEffectAndPositionZeroingEstimatorTest : public ZeroingTest {
- public:
-  // The starting position of the system.
-  static constexpr double kStartPosition = 2.0;
-
-  // Returns a reasonable set of test constants.
-  static constants::HallEffectZeroingConstants MakeConstants() {
-    constants::HallEffectZeroingConstants constants;
-    constants.lower_hall_position = 0.25;
-    constants.upper_hall_position = 0.75;
-    constants.index_difference = 1.0;
-    constants.hall_trigger_zeroing_length = 2;
-    constants.zeroing_move_direction = false;
-    return constants;
-  }
-
-  HallEffectAndPositionZeroingEstimatorTest()
-      : constants_(MakeConstants()), sim_(constants_.index_difference) {
-    // Start the system out at the starting position.
-    sim_.InitializeHallEffectAndPosition(kStartPosition,
-                                         constants_.lower_hall_position,
-                                         constants_.upper_hall_position);
-  }
-
- protected:
-  // Constants, and the simulation using them.
-  const constants::HallEffectZeroingConstants constants_;
-  PositionSensorSimulator sim_;
-};
-
-// Tests that an error is detected when the starting position changes too much.
-TEST_F(HallEffectAndPositionZeroingEstimatorTest, TestHallEffectZeroing) {
-  HallEffectAndPositionZeroingEstimator estimator(constants_);
-
-  // Should not be zeroed when we stand still.
-  for (int i = 0; i < 300; ++i) {
-    MoveTo(&sim_, &estimator, kStartPosition);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  MoveTo(&sim_, &estimator, 1.9);
-  ASSERT_FALSE(estimator.zeroed());
-
-  // Move to where the hall effect is triggered and make sure it becomes zeroed.
-  MoveTo(&sim_, &estimator, 1.5);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 1.5);
-  ASSERT_TRUE(estimator.zeroed());
-
-  // Check that the offset is calculated correctly.  We should expect to read
-  // 0.5.  Since the encoder is reading -0.5 right now, the offset needs to be
-  // 1.
-  EXPECT_DOUBLE_EQ(1.0, estimator.offset());
-
-  // Make sure triggering errors works.
-  estimator.TriggerError();
-  ASSERT_TRUE(estimator.error());
-
-  // Ensure resetting resets the state of the estimator.
-  estimator.Reset();
-  ASSERT_FALSE(estimator.zeroed());
-  ASSERT_FALSE(estimator.error());
-}
-
-// Tests that we don't zero on a too short pulse.
-TEST_F(HallEffectAndPositionZeroingEstimatorTest, TestTooShortPulse) {
-  HallEffectAndPositionZeroingEstimator estimator(constants_);
-
-  // Trigger for 1 cycle.
-  MoveTo(&sim_, &estimator, 0.9);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.5);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.9);
-  EXPECT_FALSE(estimator.zeroed());
-}
-
-// Tests that we don't zero when we go the wrong direction.
-TEST_F(HallEffectAndPositionZeroingEstimatorTest, TestWrongDirectionNoZero) {
-  HallEffectAndPositionZeroingEstimator estimator(constants_);
-
-  // Pass through the sensor, lingering long enough that we should zero.
-  MoveTo(&sim_, &estimator, 0.0);
-  ASSERT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.4);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.6);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.7);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.9);
-  EXPECT_FALSE(estimator.zeroed());
-}
-
-// Make sure we don't zero if we start in the hall effect's range.
-TEST_F(HallEffectAndPositionZeroingEstimatorTest, TestStartingOnNoZero) {
-  HallEffectAndPositionZeroingEstimator estimator(constants_);
-  MoveTo(&sim_, &estimator, 0.5);
-  estimator.Reset();
-
-  // Stay on the hall effect.  We shouldn't zero.
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.5);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.5);
-  EXPECT_FALSE(estimator.zeroed());
-
-  // Verify moving off the hall still doesn't zero us.
-  MoveTo(&sim_, &estimator, 0.0);
-  EXPECT_FALSE(estimator.zeroed());
-  MoveTo(&sim_, &estimator, 0.0);
-  EXPECT_FALSE(estimator.zeroed());
-}
-
-// Makes sure that using an absolute encoder lets us zero without moving.
-TEST_F(ZeroingTest, TestAbsoluteEncoderZeroingWithoutMovement) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-
-  const double kMiddlePosition = 2.5;
-  const double start_pos = 2.1;
-  double measured_absolute_position = 0.3 * index_diff;
-
-  AbsoluteEncoderZeroingConstants constants{
-      kSampleSize,        index_diff, measured_absolute_position,
-      kMiddlePosition,    0.1,        kMovingBufferSize,
-      kIndexErrorFraction};
-
-  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
-                 constants.measured_absolute_position);
-
-  AbsoluteEncoderZeroingEstimator estimator(constants);
-
-  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
-    MoveTo(&sim, &estimator, start_pos);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  MoveTo(&sim, &estimator, start_pos);
-  ASSERT_TRUE(estimator.zeroed());
-  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
-}
-
-// Makes sure that we ignore a NAN if we get it, but will correctly zero
-// afterwards.
-TEST_F(ZeroingTest, TestAbsoluteEncoderZeroingIgnoresNAN) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-
-  const double start_pos = 2.1;
-  double measured_absolute_position = 0.3 * index_diff;
-  const double kMiddlePosition = 2.5;
-
-  AbsoluteEncoderZeroingConstants constants{
-      kSampleSize,        index_diff, measured_absolute_position,
-      kMiddlePosition,    0.1,        kMovingBufferSize,
-      kIndexErrorFraction};
-
-  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
-                 constants.measured_absolute_position);
-
-  AbsoluteEncoderZeroingEstimator estimator(constants);
-
-  // We tolerate a couple NANs before we start.
-  FBB fbb;
-  fbb.Finish(CreateAbsolutePosition(
-      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN()));
-  const auto sensor_values =
-      flatbuffers::GetRoot<AbsolutePosition>(fbb.GetBufferPointer());
-  for (size_t i = 0; i < kSampleSize - 1; ++i) {
-    estimator.UpdateEstimate(*sensor_values);
-  }
-
-  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
-    MoveTo(&sim, &estimator, start_pos);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-
-  MoveTo(&sim, &estimator, start_pos);
-  ASSERT_TRUE(estimator.zeroed());
-  EXPECT_DOUBLE_EQ(start_pos, estimator.offset());
-}
-
-// Makes sure that using an absolute encoder doesn't let us zero while moving.
-TEST_F(ZeroingTest, TestAbsoluteEncoderZeroingWithMovement) {
-  const double index_diff = 1.0;
-  PositionSensorSimulator sim(index_diff);
-
-  const double start_pos = 10 * index_diff;
-  double measured_absolute_position = 0.3 * index_diff;
-  const double kMiddlePosition = 2.5;
-
-  AbsoluteEncoderZeroingConstants constants{
-      kSampleSize,        index_diff, measured_absolute_position,
-      kMiddlePosition,    0.1,        kMovingBufferSize,
-      kIndexErrorFraction};
-
-  sim.Initialize(start_pos, index_diff / 3.0, 0.0,
-                 constants.measured_absolute_position);
-
-  AbsoluteEncoderZeroingEstimator estimator(constants);
-
-  for (size_t i = 0; i < kSampleSize + kMovingBufferSize - 1; ++i) {
-    MoveTo(&sim, &estimator, start_pos + i * index_diff);
-    ASSERT_FALSE(estimator.zeroed());
-  }
-  MoveTo(&sim, &estimator, start_pos + 10 * index_diff);
-
-  MoveTo(&sim, &estimator, start_pos);
-  ASSERT_FALSE(estimator.zeroed());
-}
-
-// Makes sure we detect an error if the ZeroingEstimator gets sent a NaN.
-TEST_F(ZeroingTest, TestAbsoluteEncoderZeroingWithNaN) {
-  AbsoluteEncoderZeroingConstants constants{
-      kSampleSize, 1, 0.3, 1.0, 0.1, kMovingBufferSize, kIndexErrorFraction};
-
-  AbsoluteEncoderZeroingEstimator estimator(constants);
-
-  FBB fbb;
-  fbb.Finish(CreateAbsolutePosition(
-      fbb, 0.0, ::std::numeric_limits<double>::quiet_NaN()));
-  const auto sensor_values =
-      flatbuffers::GetRoot<AbsolutePosition>(fbb.GetBufferPointer());
-  for (size_t i = 0; i < kSampleSize - 1; ++i) {
-    estimator.UpdateEstimate(*sensor_values);
-  }
-  ASSERT_FALSE(estimator.error());
-
-  estimator.UpdateEstimate(*sensor_values);
-  ASSERT_TRUE(estimator.error());
-}
-
-TEST_F(ZeroingTest, TestRelativeEncoderZeroingWithoutMovement) {
-  PositionSensorSimulator sim(1.0);
-  RelativeEncoderZeroingEstimator estimator;
-
-  sim.InitializeRelativeEncoder();
-
-  ASSERT_TRUE(estimator.zeroed());
-  ASSERT_TRUE(estimator.offset_ready());
-  EXPECT_DOUBLE_EQ(estimator.offset(), 0.0);
-  EXPECT_DOUBLE_EQ(GetEstimatorPosition(&estimator), 0.0);
-
-  MoveTo(&sim, &estimator, 0.1);
-
-  EXPECT_DOUBLE_EQ(GetEstimatorPosition(&estimator), 0.1);
-}
-
-}  // namespace zeroing
-}  // namespace frc971
diff --git a/frc971/zeroing/zeroing_test.h b/frc971/zeroing/zeroing_test.h
new file mode 100644
index 0000000..9b7ba95
--- /dev/null
+++ b/frc971/zeroing/zeroing_test.h
@@ -0,0 +1,32 @@
+#include "frc971/zeroing/zeroing.h"
+
+#include "frc971/control_loops/control_loops_generated.h"
+#include "frc971/control_loops/position_sensor_sim.h"
+#include "gtest/gtest.h"
+
+namespace frc971 {
+namespace zeroing {
+namespace testing {
+
+using control_loops::PositionSensorSimulator;
+using FBB = flatbuffers::FlatBufferBuilder;
+
+constexpr size_t kSampleSize = 30;
+constexpr double kAcceptableUnzeroedError = 0.2;
+constexpr double kIndexErrorFraction = 0.3;
+constexpr size_t kMovingBufferSize = 3;
+
+class ZeroingTest : public ::testing::Test {
+ protected:
+  template <typename T>
+  double GetEstimatorPosition(T *estimator) {
+    FBB fbb;
+    fbb.Finish(estimator->GetEstimatorState(&fbb));
+    return flatbuffers::GetRoot<typename T::State>(fbb.GetBufferPointer())
+        ->position();
+  }
+};
+
+}  // namespace testing
+}  // namespace zeroing
+}  // namespace frc971
diff --git a/third_party/BUILD b/third_party/BUILD
index fd10d43..bcba978 100644
--- a/third_party/BUILD
+++ b/third_party/BUILD
@@ -44,6 +44,20 @@
 )
 
 cc_library(
+    name = "gstreamer",
+    restricted_to = [
+        "//tools:k8",
+        "//tools:armhf-debian",
+    ],
+    visibility = ["//visibility:public"],
+    deps = select({
+        "//tools:cpu_k8": ["@gstreamer_k8//:gstreamer"],
+        "//tools:cpu_armhf": ["@gstreamer_armhf//:gstreamer"],
+        "//conditions:default": [],
+    }),
+)
+
+cc_library(
     name = "halide",
     restricted_to = [
         "//tools:k8",
diff --git a/third_party/google-glog/src/logging.cc b/third_party/google-glog/src/logging.cc
index ad4047d..2bfce3d 100644
--- a/third_party/google-glog/src/logging.cc
+++ b/third_party/google-glog/src/logging.cc
@@ -1459,6 +1459,13 @@
   // someone else can use them (as long as they flush afterwards)
   if (data_->severity_ == GLOG_FATAL && exit_on_dfatal) {
     if (data_->first_fatal_) {
+      {
+        // Put this back on SCHED_OTHER by default.
+        struct sched_param param;
+        param.sched_priority = 0;
+        sched_setscheduler(0, SCHED_OTHER, &param);
+      }
+
       // Store crash information so that it is accessible from within signal
       // handlers that may be invoked later.
       RecordCrashReason(&crash_reason);
diff --git a/third_party/google-glog/src/signalhandler.cc b/third_party/google-glog/src/signalhandler.cc
index c3a0f80..049efa5 100644
--- a/third_party/google-glog/src/signalhandler.cc
+++ b/third_party/google-glog/src/signalhandler.cc
@@ -308,6 +308,14 @@
       sleep(1);
     }
   }
+
+  {
+    // Put this back on SCHED_OTHER by default.
+    struct sched_param param;
+    param.sched_priority = 0;
+    sched_setscheduler(0, SCHED_OTHER, &param);
+  }
+
   // This is the first time we enter the signal handler.  We are going to
   // do some interesting stuff from here.
   // TODO(satorux): We might want to set timeout here using alarm(), but
diff --git a/y2019/control_loops/drivetrain/localizer_test.cc b/y2019/control_loops/drivetrain/localizer_test.cc
index 7b25ca5..e3b6398 100644
--- a/y2019/control_loops/drivetrain/localizer_test.cc
+++ b/y2019/control_loops/drivetrain/localizer_test.cc
@@ -599,7 +599,7 @@
             /*noisify=*/true,
             /*disturb=*/false,
             /*estimate_tolerance=*/0.4,
-            /*goal_tolerance=*/0.4,
+            /*goal_tolerance=*/0.8,
         }),
         // Repeats perfect scenario, but add initial estimator error.
         LocalizerTestParams({
@@ -629,7 +629,7 @@
             /*noisify=*/false,
             /*disturb=*/false,
             /*estimate_tolerance=*/1e-2,
-            /*goal_tolerance=*/2e-2,
+            /*goal_tolerance=*/3e-2,
         }),
         // Add disturbances while we are driving:
         LocalizerTestParams({
diff --git a/y2020/BUILD b/y2020/BUILD
index 320a0cf..5b7560d 100644
--- a/y2020/BUILD
+++ b/y2020/BUILD
@@ -24,6 +24,9 @@
 
 robot_downloader(
     name = "pi_download",
+    binaries = [
+        "//y2020/vision:viewer",
+    ],
     data = [
         ":config.json",
     ],
diff --git a/y2020/constants.cc b/y2020/constants.cc
index 463919a..eefc158 100644
--- a/y2020/constants.cc
+++ b/y2020/constants.cc
@@ -76,7 +76,7 @@
 
   // Turret Constants
   turret_params->zeroing_voltage = 4.0;
-  turret_params->operating_voltage = 12.0;
+  turret_params->operating_voltage = 8.0;
   // TODO(austin): Tune these.
   turret_params->zeroing_profile_params = {0.5, 2.0};
   turret_params->default_profile_params = {15.0, 40.0};
diff --git a/y2020/control_loops/python/flywheel.py b/y2020/control_loops/python/flywheel.py
index 451788a..f284450 100755
--- a/y2020/control_loops/python/flywheel.py
+++ b/y2020/control_loops/python/flywheel.py
@@ -295,6 +295,18 @@
     loop_writer.AddConstant(
         control_loop.Constant('kFreeSpeed', '%f',
                               flywheels[0].motor.free_speed))
+    loop_writer.AddConstant(
+        control_loop.Constant(
+            'kBemf',
+            '%f',
+            flywheels[0].motor.Kv * flywheels[0].G,
+            comment="// Radians/sec / volt"))
+    loop_writer.AddConstant(
+        control_loop.Constant(
+            'kResistance',
+            '%f',
+            flywheels[0].motor.resistance,
+            comment="// Ohms"))
     loop_writer.Write(plant_files[0], plant_files[1])
 
     integral_loop_writer = control_loop.ControlLoopWriter(
diff --git a/y2020/control_loops/superstructure/shooter/flywheel_controller.cc b/y2020/control_loops/superstructure/shooter/flywheel_controller.cc
index 07c3d99..a8921d9 100644
--- a/y2020/control_loops/superstructure/shooter/flywheel_controller.cc
+++ b/y2020/control_loops/superstructure/shooter/flywheel_controller.cc
@@ -11,12 +11,56 @@
 namespace superstructure {
 namespace shooter {
 
+// Class to current limit battery current for a flywheel controller.
+class CurrentLimitedStateFeedbackController
+    : public StateFeedbackLoop<3, 1, 1, double,
+                               StateFeedbackHybridPlant<3, 1, 1>,
+                               HybridKalman<3, 1, 1>> {
+ public:
+  // Builds a CurrentLimitedStateFeedbackController given the coefficients, bemf
+  // coefficient (units of radians/sec / volt), and motor resistance in ohms.
+  CurrentLimitedStateFeedbackController(
+      StateFeedbackLoop<3, 1, 1, double, StateFeedbackHybridPlant<3, 1, 1>,
+                        HybridKalman<3, 1, 1>> &&other,
+      double bemf, double resistance)
+      : StateFeedbackLoop(std::move(other)),
+        bemf_(bemf),
+        resistance_(resistance) {}
+
+  void CapU() override {
+    const double bemf_voltage = X_hat(1) / bemf_;
+    // Solve the system of equations:
+    //
+    //   motor_current = (u - bemf_voltage) / resistance
+    //   battery_current = ((u - bemf_voltage) / resistance) * u / 12.0
+    //   0.0 = u * u - u * bemf_voltage - max_current * 12.0 * resistance
+    //
+    // And we have a quadratic!
+    const double a = 1;
+    const double b = -bemf_voltage;
+    const double c = -50.0 * 12.0 * resistance_;
+
+    // Root is always positive.
+    const double root = std::sqrt(b * b - 4.0 * a * c);
+    const double upper_limit = (-b + root) / (2.0 * a);
+    const double lower_limit = (-b - root) / (2.0 * a);
+
+    // Limit to the battery voltage and the current limit voltage.
+    mutable_U(0, 0) = std::clamp(U(0, 0), lower_limit, upper_limit);
+    mutable_U(0, 0) = std::clamp(U(0, 0), -12.0, 12.0);
+  }
+
+ private:
+  double bemf_ = 0.0;
+  double resistance_ = 0.0;
+};
+
 FlywheelController::FlywheelController(
     StateFeedbackLoop<3, 1, 1, double, StateFeedbackHybridPlant<3, 1, 1>,
-                      HybridKalman<3, 1, 1>> &&loop)
-    : loop_(new StateFeedbackLoop<3, 1, 1, double,
-                                  StateFeedbackHybridPlant<3, 1, 1>,
-                                  HybridKalman<3, 1, 1>>(std::move(loop))) {
+                      HybridKalman<3, 1, 1>> &&loop,
+    double bemf, double resistance)
+    : loop_(new CurrentLimitedStateFeedbackController(std::move(loop), bemf,
+                                                      resistance)) {
   history_.fill(std::pair<double, ::aos::monotonic_clock::time_point>(
       0, ::aos::monotonic_clock::epoch()));
   Y_.setZero();
diff --git a/y2020/control_loops/superstructure/shooter/flywheel_controller.h b/y2020/control_loops/superstructure/shooter/flywheel_controller.h
index e130389..d5f7ede 100644
--- a/y2020/control_loops/superstructure/shooter/flywheel_controller.h
+++ b/y2020/control_loops/superstructure/shooter/flywheel_controller.h
@@ -20,7 +20,8 @@
  public:
   FlywheelController(
       StateFeedbackLoop<3, 1, 1, double, StateFeedbackHybridPlant<3, 1, 1>,
-                        HybridKalman<3, 1, 1>> &&loop);
+                        HybridKalman<3, 1, 1>> &&loop,
+      double bemf, double resistance);
 
   // Sets the velocity goal in radians/sec
   void set_goal(double angular_velocity_goal);
diff --git a/y2020/control_loops/superstructure/shooter/shooter.cc b/y2020/control_loops/superstructure/shooter/shooter.cc
index a9f1c4c..6e48a21 100644
--- a/y2020/control_loops/superstructure/shooter/shooter.cc
+++ b/y2020/control_loops/superstructure/shooter/shooter.cc
@@ -16,9 +16,12 @@
 }  // namespace
 
 Shooter::Shooter()
-    : finisher_(finisher::MakeIntegralFinisherLoop()),
-      accelerator_left_(accelerator::MakeIntegralAcceleratorLoop()),
-      accelerator_right_(accelerator::MakeIntegralAcceleratorLoop()) {}
+    : finisher_(finisher::MakeIntegralFinisherLoop(), finisher::kBemf,
+                finisher::kResistance),
+      accelerator_left_(accelerator::MakeIntegralAcceleratorLoop(),
+                        accelerator::kBemf, accelerator::kResistance),
+      accelerator_right_(accelerator::MakeIntegralAcceleratorLoop(),
+                         accelerator::kBemf, accelerator::kResistance) {}
 
 bool Shooter::UpToSpeed(const ShooterGoal *goal) {
   return (
diff --git a/y2020/control_loops/superstructure/superstructure.cc b/y2020/control_loops/superstructure/superstructure.cc
index 8947f85..0d740e9 100644
--- a/y2020/control_loops/superstructure/superstructure.cc
+++ b/y2020/control_loops/superstructure/superstructure.cc
@@ -40,7 +40,8 @@
 
   if (drivetrain_status_fetcher_.Fetch()) {
     aos::Alliance alliance = aos::Alliance::kInvalid;
-    if (joystick_state_fetcher_.Fetch()) {
+    joystick_state_fetcher_.Fetch();
+    if (joystick_state_fetcher_.get() != nullptr) {
       alliance = joystick_state_fetcher_->alliance();
     }
     const turret::Aimer::WrapMode mode =
@@ -120,7 +121,8 @@
 
   if (output != nullptr) {
     // Friction is a pain and putting a really high burden on the integrator.
-    const double turret_velocity_sign = turret_status->velocity() * kTurretFrictionGain;
+    const double turret_velocity_sign =
+        turret_status->velocity() * kTurretFrictionGain;
     output_struct.turret_voltage +=
         std::clamp(turret_velocity_sign, -kTurretFrictionVoltageLimit,
                    kTurretFrictionVoltageLimit);
diff --git a/y2020/control_loops/superstructure/superstructure_lib_test.cc b/y2020/control_loops/superstructure/superstructure_lib_test.cc
index e8f1f8d..1d42d23 100644
--- a/y2020/control_loops/superstructure/superstructure_lib_test.cc
+++ b/y2020/control_loops/superstructure/superstructure_lib_test.cc
@@ -43,14 +43,25 @@
 
 class FlywheelPlant : public StateFeedbackPlant<2, 1, 1> {
  public:
-  explicit FlywheelPlant(StateFeedbackPlant<2, 1, 1> &&other)
-      : StateFeedbackPlant<2, 1, 1>(::std::move(other)) {}
+  explicit FlywheelPlant(StateFeedbackPlant<2, 1, 1> &&other, double bemf,
+                         double resistance)
+      : StateFeedbackPlant<2, 1, 1>(::std::move(other)),
+        bemf_(bemf),
+        resistance_(resistance) {}
 
   void CheckU(const Eigen::Matrix<double, 1, 1> &U) override {
     EXPECT_LE(U(0, 0), U_max(0, 0) + 0.00001 + voltage_offset_);
     EXPECT_GE(U(0, 0), U_min(0, 0) - 0.00001 + voltage_offset_);
   }
 
+  double motor_current(const Eigen::Matrix<double, 1, 1> U) const {
+    return (U(0) - X(1) / bemf_) / resistance_;
+  }
+
+  double battery_current(const Eigen::Matrix<double, 1, 1> U) const {
+    return motor_current(U) * U(0) / 12.0;
+  }
+
   double voltage_offset() const { return voltage_offset_; }
   void set_voltage_offset(double voltage_offset) {
     voltage_offset_ = voltage_offset;
@@ -58,6 +69,9 @@
 
  private:
   double voltage_offset_ = 0.0;
+
+  double bemf_;
+  double resistance_;
 };
 
 // Class which simulates the superstructure and sends out queue messages with
@@ -84,10 +98,14 @@
                             .turret.subsystem_params.zeroing_constants
                             .one_revolution_distance),
         accelerator_left_plant_(
-            new FlywheelPlant(accelerator::MakeAcceleratorPlant())),
+            new FlywheelPlant(accelerator::MakeAcceleratorPlant(),
+                              accelerator::kBemf, accelerator::kResistance)),
         accelerator_right_plant_(
-            new FlywheelPlant(accelerator::MakeAcceleratorPlant())),
-        finisher_plant_(new FlywheelPlant(finisher::MakeFinisherPlant())) {
+            new FlywheelPlant(accelerator::MakeAcceleratorPlant(),
+                              accelerator::kBemf, accelerator::kResistance)),
+        finisher_plant_(new FlywheelPlant(finisher::MakeFinisherPlant(),
+                                          finisher::kBemf,
+                                          finisher::kResistance)) {
     InitializeHoodPosition(constants::Values::kHoodRange().upper);
     InitializeIntakePosition(constants::Values::kIntakeRange().upper);
     InitializeTurretPosition(constants::Values::kTurretRange().middle());
@@ -264,15 +282,26 @@
         << superstructure_output_fetcher_->accelerator_left_voltage() +
                accelerator_left_plant_->voltage_offset();
 
+    // Confirm that we aren't drawing too much current.
+    CHECK_NEAR(accelerator_left_plant_->battery_current(accelerator_left_U),
+               0.0, 60.0);
+
     ::Eigen::Matrix<double, 1, 1> accelerator_right_U;
     accelerator_right_U
         << superstructure_output_fetcher_->accelerator_right_voltage() +
                accelerator_right_plant_->voltage_offset();
 
+    // Confirm that we aren't drawing too much current.
+    CHECK_NEAR(accelerator_right_plant_->battery_current(accelerator_right_U),
+               0.0, 60.0);
+
     ::Eigen::Matrix<double, 1, 1> finisher_U;
     finisher_U << superstructure_output_fetcher_->finisher_voltage() +
                       finisher_plant_->voltage_offset();
 
+    // Confirm that we aren't drawing too much current.
+    CHECK_NEAR(finisher_plant_->battery_current(finisher_U), 0.0, 60.0);
+
     hood_plant_->Update(hood_U);
     intake_plant_->Update(intake_U);
     turret_plant_->Update(turret_U);
diff --git a/y2020/control_loops/superstructure/superstructure_status.fbs b/y2020/control_loops/superstructure/superstructure_status.fbs
index 81293d3..dc6116c 100644
--- a/y2020/control_loops/superstructure/superstructure_status.fbs
+++ b/y2020/control_loops/superstructure/superstructure_status.fbs
@@ -36,6 +36,11 @@
   turret_velocity:double;
   // Whether we are currently aiming for the inner port.
   aiming_for_inner_port:bool;
+  // The current distance to the target, in meters.
+  target_distance:double;
+  // The current "shot distance." When shooting on the fly, this may be
+  // different from the static distance to the target.
+  shot_distance:double;
 }
 
 table Status {
diff --git a/y2020/control_loops/superstructure/turret/aiming.cc b/y2020/control_loops/superstructure/turret/aiming.cc
index 360fd1a..0ce4871 100644
--- a/y2020/control_loops/superstructure/turret/aiming.cc
+++ b/y2020/control_loops/superstructure/turret/aiming.cc
@@ -50,8 +50,10 @@
 // outer port entirely.
 constexpr double kMaxInnerPortAngle = 20.0 * M_PI / 180.0;
 
-// Distance (in meters) from the edge of the field to the port.
-constexpr double kEdgeOfFieldToPort = 2.404;
+// Distance (in meters) from the edge of the field to the port, with some
+// compensation to ensure that our definition of where the target is matches
+// that reported by the cameras.
+constexpr double kEdgeOfFieldToPort = 2.404 + .0034;
 
 // The amount (in meters) that the inner port is set back from the outer port.
 constexpr double kInnerPortBackset = 0.743;
@@ -70,7 +72,7 @@
 // Minimum distance that we must be from the inner port in order to attempt the
 // shot--this is to account for the fact that if we are too close to the target,
 // then we won't have a clear shot on the inner port.
-constexpr double kMinimumInnerPortShotDistance = 4.0;
+constexpr double kMinimumInnerPortShotDistance = 3.0;
 
 // Amount of buffer, in radians, to leave to help avoid wrapping. I.e., any time
 // that we are in kAvoidEdges mode, we will keep ourselves at least
@@ -123,7 +125,7 @@
 Pose InnerPortPose(aos::Alliance alliance) {
   const Pose target({kFieldLength / 2 + kInnerPortBackset,
                      -kFieldWidth / 2.0 + kEdgeOfFieldToPort, kPortHeight},
-                    0.0);
+                    M_PI);
   if (alliance == aos::Alliance::kRed) {
     return ReverseSideOfField(target);
   }
@@ -133,7 +135,7 @@
 Pose OuterPortPose(aos::Alliance alliance) {
   Pose target(
       {kFieldLength / 2, -kFieldWidth / 2.0 + kEdgeOfFieldToPort, kPortHeight},
-      0.0);
+      M_PI);
   if (alliance == aos::Alliance::kRed) {
     return ReverseSideOfField(target);
   }
@@ -164,9 +166,16 @@
 
   const double inner_port_angle = robot_pose_from_inner_port.heading();
   const double inner_port_distance = robot_pose_from_inner_port.xy_norm();
+  // Add a bit of hysteresis so that we don't jump between aiming for the inner
+  // and outer ports.
+  const double max_inner_port_angle =
+      aiming_for_inner_port_ ? 1.2 * kMaxInnerPortAngle : kMaxInnerPortAngle;
+  const double min_inner_port_distance =
+      aiming_for_inner_port_ ? 0.8 * kMinimumInnerPortShotDistance
+                             : kMinimumInnerPortShotDistance;
   aiming_for_inner_port_ =
-      (std::abs(inner_port_angle) < kMaxInnerPortAngle) &&
-      (inner_port_distance > kMinimumInnerPortShotDistance);
+      (std::abs(inner_port_angle) < max_inner_port_angle) &&
+      (inner_port_distance > min_inner_port_distance);
 
   // This code manages compensating the goal turret heading for the robot's
   // current velocity, to allow for shooting on-the-fly.
@@ -177,6 +186,7 @@
   Pose virtual_goal;
   {
     const Pose goal = aiming_for_inner_port_ ? inner_port : outer_port;
+    target_distance_ = goal.Rebase(&robot_pose).xy_norm();
     virtual_goal = goal;
     if (shot_mode == ShotMode::kShootOnTheFly) {
       for (int ii = 0; ii < 3; ++ii) {
@@ -191,7 +201,7 @@
 
   const double heading_to_goal = virtual_goal.heading();
   CHECK(status->has_localizer());
-  distance_ = virtual_goal.xy_norm();
+  shot_distance_ = virtual_goal.xy_norm();
 
   // The following code all works to calculate what the rate of turn of the
   // turret should be. The code only accounts for the rate of turn if we are
@@ -201,6 +211,12 @@
   const double rel_x = virtual_goal.rel_pos().x();
   const double rel_y = virtual_goal.rel_pos().y();
   const double squared_norm = rel_x * rel_x + rel_y * rel_y;
+  // rel_xdot and rel_ydot are the derivatives (with respect to time) of rel_x
+  // and rel_y. Since these are in the robot's coordinate frame, and since we
+  // are ignoring lateral velocity for this exercise, rel_ydot is zero, and
+  // rel_xdot is just the inverse of the robot's velocity.
+  const double rel_xdot = -linear_angular(0);
+  const double rel_ydot = 0.0;
 
   // If squared_norm gets to be too close to zero, just zero out the relevant
   // term to prevent NaNs. Note that this doesn't address the chattering that
@@ -208,11 +224,12 @@
   // Note that x and y terms are swapped relative to what you would normally see
   // in the derivative of atan because xdot and ydot are the derivatives of
   // robot_pos and we are working with the atan of (target_pos - robot_pos).
-  const double atan_diff = (squared_norm < 1e-3)
-                               ? 0.0
-                               : (rel_y * xdot - rel_x * ydot) / squared_norm;
+  const double atan_diff =
+      (squared_norm < 1e-3) ? 0.0 : (rel_x * rel_ydot - rel_y * rel_xdot) /
+                                        squared_norm;
   // heading = atan2(relative_y, relative_x) - robot_theta
-  // dheading / dt = (rel_x * rel_y' - rel_y * rel_x') / (rel_x^2 + rel_y^2) - dtheta / dt
+  // dheading / dt =
+  //     (rel_x * rel_y' - rel_y * rel_x') / (rel_x^2 + rel_y^2) - dtheta / dt
   const double dheading_dt = atan_diff - linear_angular(1);
 
   double range = kTurretRange;
@@ -234,7 +251,8 @@
   }
 
   goal_.mutable_message()->mutate_unsafe_goal(turret_heading);
-  goal_.mutable_message()->mutate_goal_velocity(dheading_dt);
+  goal_.mutable_message()->mutate_goal_velocity(
+      std::clamp(dheading_dt, -2.0, 2.0));
 }
 
 flatbuffers::Offset<AimerStatus> Aimer::PopulateStatus(
@@ -243,6 +261,8 @@
   builder.add_turret_position(goal_.message().unsafe_goal());
   builder.add_turret_velocity(goal_.message().goal_velocity());
   builder.add_aiming_for_inner_port(aiming_for_inner_port_);
+  builder.add_target_distance(target_distance_);
+  builder.add_shot_distance(DistanceToGoal());
   return builder.Finish();
 }
 
diff --git a/y2020/control_loops/superstructure/turret/aiming.h b/y2020/control_loops/superstructure/turret/aiming.h
index 3b3071e..854518c 100644
--- a/y2020/control_loops/superstructure/turret/aiming.h
+++ b/y2020/control_loops/superstructure/turret/aiming.h
@@ -56,7 +56,7 @@
   const Goal *TurretGoal() const { return &goal_.message(); }
 
   // Returns the distance to the goal, in meters.
-  double DistanceToGoal() const { return distance_; }
+  double DistanceToGoal() const { return shot_distance_; }
 
   flatbuffers::Offset<AimerStatus> PopulateStatus(
       flatbuffers::FlatBufferBuilder *fbb) const;
@@ -64,7 +64,11 @@
  private:
   aos::FlatbufferDetachedBuffer<Goal> goal_;
   bool aiming_for_inner_port_ = false;
-  double distance_ = 0.0;
+  // Distance of the shot to the virtual target, used for calculating hood
+  // position and shooter speed.
+  double shot_distance_ = 0.0;    // meters
+  // Real-world distance to the target.
+  double target_distance_ = 0.0;  // meters
 };
 
 }  // namespace turret
diff --git a/y2020/control_loops/superstructure/turret/aiming_test.cc b/y2020/control_loops/superstructure/turret/aiming_test.cc
index cb95b56..ab600fa 100644
--- a/y2020/control_loops/superstructure/turret/aiming_test.cc
+++ b/y2020/control_loops/superstructure/turret/aiming_test.cc
@@ -178,7 +178,7 @@
 // angle on it.
 TEST_F(AimerTest, InnerPort) {
   const Pose target = InnerPortPose(aos::Alliance::kRed);
-  const Goal *goal = Update({.x = target.abs_pos().x() + 1.0,
+  const Goal *goal = Update({.x = target.abs_pos().x() + 10.0,
                              .y = target.abs_pos().y() + 0.0,
                              .theta = 0.0,
                              .linear = 0.0,
@@ -186,6 +186,7 @@
                             aos::Alliance::kRed);
   EXPECT_EQ(0.0, goal->unsafe_goal());
   EXPECT_EQ(0.0, goal->goal_velocity());
+  EXPECT_LT(1.0, aimer_.DistanceToGoal());
 }
 
 // Confirms that when we move the turret heading so that it would be entirely
diff --git a/y2020/vision/BUILD b/y2020/vision/BUILD
index 3baa61b..86088e6 100644
--- a/y2020/vision/BUILD
+++ b/y2020/vision/BUILD
@@ -78,6 +78,7 @@
         "//aos:init",
         "//aos/events:shm_event_loop",
         "//third_party:opencv",
+        "//y2020/vision/sift:sift_fbs",
     ],
 )
 
diff --git a/y2020/vision/camera_reader.cc b/y2020/vision/camera_reader.cc
index f38a40e..d0479d2 100644
--- a/y2020/vision/camera_reader.cc
+++ b/y2020/vision/camera_reader.cc
@@ -521,14 +521,15 @@
   std::vector<std::vector<sift::Match>> per_image_matches(
       number_training_images());
   for (const std::vector<cv::DMatch> &image_matches : matches) {
-    for (const cv::DMatch &image_match : image_matches) {
-      CHECK_LT(image_match.imgIdx, number_training_images());
-      per_image_matches[image_match.imgIdx].emplace_back();
-      sift::Match *const match = &per_image_matches[image_match.imgIdx].back();
-      match->mutate_query_feature(image_match.queryIdx);
-      match->mutate_train_feature(image_match.trainIdx);
-      match->mutate_distance(image_match.distance);
-    }
+    CHECK_GT(image_matches.size(), 0u);
+    // We're only using the first of the two matches
+    const cv::DMatch &image_match = image_matches[0];
+    CHECK_LT(image_match.imgIdx, number_training_images());
+    per_image_matches[image_match.imgIdx].emplace_back();
+    sift::Match *const match = &per_image_matches[image_match.imgIdx].back();
+    match->mutate_query_feature(image_match.queryIdx);
+    match->mutate_train_feature(image_match.trainIdx);
+    match->mutate_distance(image_match.distance);
   }
 
   // Then, we need to build up each ImageMatch table.
diff --git a/y2020/vision/tools/python_code/BUILD b/y2020/vision/tools/python_code/BUILD
index a932886..53464ac 100644
--- a/y2020/vision/tools/python_code/BUILD
+++ b/y2020/vision/tools/python_code/BUILD
@@ -12,13 +12,9 @@
     args = [
         "sift_training_data.h",
     ],
-    data = [
-        ":test_images/train_loading_bay_blue.png",
-        ":test_images/train_loading_bay_red.png",
-        ":test_images/train_power_port_blue.png",
-        ":test_images/train_power_port_red.png",
-        ":test_images/train_power_port_red_webcam.png",
-    ],
+    data = glob(["calib_files/*.json"]) + glob([
+        "test_images/*.png",
+    ]),
     default_python_version = "PY3",
     srcs_version = "PY2AND3",
     deps = [
@@ -64,13 +60,14 @@
         "sift_training_data_test.h",
         "test",
     ],
-    data = [
-        ":test_images/train_power_port_red.png",
-    ],
+    data = glob(["calib_files/*.json"]) + glob([
+        "test_images/*.png",
+    ]),
     default_python_version = "PY3",
     main = "load_sift_training.py",
     srcs_version = "PY2AND3",
     deps = [
+        ":load_sift_training",
         "//external:python-glog",
         "//y2020/vision/sift:sift_fbs_python",
         "@bazel_tools//tools/python/runfiles",
diff --git a/y2020/vision/tools/python_code/calib_files/cam-calib-int_pi-7971-3_Feb-13-2020-00-00-00.json b/y2020/vision/tools/python_code/calib_files/cam-calib-int_pi-7971-3_Feb-13-2020-00-00-00.json
new file mode 100644
index 0000000..8c1efbb
--- /dev/null
+++ b/y2020/vision/tools/python_code/calib_files/cam-calib-int_pi-7971-3_Feb-13-2020-00-00-00.json
@@ -0,0 +1 @@
+{"hostname": "pi-7971-3", "node_name": "pi3", "team_number": 7971, "timestamp": "Feb-13-2020-00-00-00", "camera_matrix": [[388.79947319784713, 0.0, 345.0976031055917], [0.0, 388.539148344188, 265.2780372766764], [0.0, 0.0, 1.0]], "dist_coeffs": [[0.13939139612079282, -0.24345067782097646, -0.0004228219772016648, -0.0004552350162154737, 0.08966339831250879]]}
diff --git a/y2020/vision/tools/python_code/calib_files/cam-calib-int_pi-971-1_2020-03-07-15-34-00.json b/y2020/vision/tools/python_code/calib_files/cam-calib-int_pi-971-1_2020-03-07-15-34-00.json
new file mode 100644
index 0000000..cf45ef0
--- /dev/null
+++ b/y2020/vision/tools/python_code/calib_files/cam-calib-int_pi-971-1_2020-03-07-15-34-00.json
@@ -0,0 +1 @@
+{"hostname": "pi-971-1", "node_name": "pi1", "team_number": 971, "timestamp": "2020-03-07-15-34-00", "camera_matrix": [[387.95046316, 0.0, 341.13297242], [0.0, 387.85366427, 245.69219733], [0.0, 0.0, 1.0]], "dist_coeffs": [[ 0.13594152, -0.23946991, -0.00088608,  0.00038653,  0.08745377]]}
diff --git a/y2020/vision/tools/python_code/calibrate_intrinsics.py b/y2020/vision/tools/python_code/calibrate_intrinsics.py
index df1b328..fb95599 100644
--- a/y2020/vision/tools/python_code/calibrate_intrinsics.py
+++ b/y2020/vision/tools/python_code/calibrate_intrinsics.py
@@ -1,23 +1,62 @@
-import time
 import cv2
-import cv2.aruco as A
+import cv2.aruco
+import datetime
+import json
+from json import JSONEncoder
 import numpy as np
+import os
+import time
 
-dictionary = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)
-board = cv2.aruco.CharucoBoard_create(11, 8, .015, .011, dictionary)
-img = board.draw((200 * 11, 200 * 8))
+
+# From: https://pynative.com/python-serialize-numpy-ndarray-into-json/
+class NumpyArrayEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        else:
+            return super(NumpyArrayEncoder, self).default(obj)
+
+
+def get_robot_info(hostname):
+    hostname_split = hostname.split("-")
+    if hostname_split[0] != "pi":
+        print(
+            "ERROR: expected hostname to start with pi!  Got '%s'" % hostname)
+        quit()
+
+    team_number = int(hostname_split[1])
+    node_name = hostname_split[0] + hostname_split[2]
+    return node_name, team_number
+
+
+USE_LARGE_BOARD = True
+
+if USE_LARGE_BOARD:
+    dictionary = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_5X5_100)
+    board = cv2.aruco.CharucoBoard_create(12, 9, .06, .045, dictionary)
+    img = board.draw((200 * 12, 200 * 9))
+else:
+    dictionary = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)
+    board = cv2.aruco.CharucoBoard_create(11, 8, .015, .011, dictionary)
+    img = board.draw((200 * 11, 200 * 8))
 
 #Dump the calibration board to a file
-cv2.imwrite('charuco.png', img)
+#cv2.imwrite('charuco.png', img)
 
 #Start capturing images for calibration
-CAMERA_INDEX = 2
+CAMERA_INDEX = 0  # Capture from /dev/videoX, where X=CAMERA_INDEX
 cap = cv2.VideoCapture(CAMERA_INDEX)
 
 allCorners = []
 allIds = []
 capture_count = 0
-while (capture_count < 50):
+MIN_IMAGES = 50
+
+while (capture_count < MIN_IMAGES):
 
     ret, frame = cap.read()
     assert ret, "Unable to get image from the camera at /dev/video%d" % CAMERA_INDEX
@@ -25,45 +64,69 @@
     res = cv2.aruco.detectMarkers(gray, dictionary)
     aruco_detect_image = frame.copy()
 
-    if len(res[0]) > 0:
+    if len(res[0]) > 0 and len(res[1]) > 0:
         cv2.aruco.drawDetectedMarkers(aruco_detect_image, res[0], res[1])
 
+    # Display every image to let user trigger capture
     cv2.imshow('frame', aruco_detect_image)
     keystroke = cv2.waitKey(1)
+
     if keystroke & 0xFF == ord('q'):
         break
     elif keystroke & 0xFF == ord('c'):
-        print("Res:", len(res[0]), res[1].shape)
+        print("Asked to capture image")
+        if len(res[0]) == 0 or len(res[1]) == 0:
+            # Can't use this image
+            continue
+
         res2 = cv2.aruco.interpolateCornersCharuco(res[0], res[1], gray, board)
         if res2[1] is not None and res2[2] is not None and len(res2[1]) > 3:
             capture_count += 1
             charuco_detect_image = frame.copy()
             allCorners.append(res2[1])
             allIds.append(res2[2])
-            print("Res2: ", res2[1].shape, res2[2].shape)
+            print("Capturing image #%d" % capture_count)
             cv2.aruco.drawDetectedCornersCharuco(charuco_detect_image, res2[1],
                                                  res2[2])
+
             cv2.imshow('frame', charuco_detect_image)
             cv2.waitKey(1000)
-            # TODO: Should log image to disk
-            print("Captured image #", capture_count)
-
-imsize = gray.shape
+            # TODO<Jim>: Should log image to disk
 
 #Calibration fails for lots of reasons. Release the video if we do
 try:
+    imsize = gray.shape
     cal = cv2.aruco.calibrateCameraCharuco(allCorners, allIds, board, imsize,
                                            None, None)
-    #print("Calibration is:\n", cal)
+    print("Calibration is:\n", cal)
     print("Reproduction error:", cal[0])
     if (cal[0] > 1.0):
         print("REPRODUCTION ERROR NOT GOOD")
-    # TODO<jim>: Need to save these out in format that can be used elsewhere
     print("Calibration matrix:\n", cal[1])
     print("Distortion Coefficients:\n", cal[2])
 except:
     print("Calibration failed")
     cap.release()
+    quit()
+
+hostname = os.uname()[1]
+date_str = datetime.datetime.today().strftime("%Y-%m-%d-%H-%M-%S")
+node_name, team_number = get_robot_info(hostname)
+numpyData = {
+    "hostname": hostname,
+    "node_name": node_name,
+    "team_number": team_number,
+    "timestamp": date_str,
+    "camera_matrix": cal[1],
+    "dist_coeffs": cal[2]
+}
+encodedNumpyData = json.dumps(
+    numpyData, cls=NumpyArrayEncoder)  # use dump() to write array into file
+
+# Write out the data
+calib_file = open("cam_calib_%s_%s.json" % (hostname, date_str), "w")
+calib_file.write(encodedNumpyData)
+calib_file.close()
 
 cap.release()
 cv2.destroyAllWindows()
diff --git a/y2020/vision/tools/python_code/camera_definition.py b/y2020/vision/tools/python_code/camera_definition.py
index 0667b16..b8c71ff 100644
--- a/y2020/vision/tools/python_code/camera_definition.py
+++ b/y2020/vision/tools/python_code/camera_definition.py
@@ -1,6 +1,13 @@
 import copy
+import glog
+import json
 import math
 import numpy as np
+import os
+
+import define_training_data as dtd
+
+glog.setLevel("WARN")
 
 
 class CameraIntrinsics:
@@ -21,41 +28,91 @@
     def __init__(self):
         self.camera_int = CameraIntrinsics()
         self.camera_ext = CameraExtrinsics()
+        self.turret_ext = None
         self.node_name = ""
         self.team_number = -1
 
 
-### CAMERA DEFINITIONS
+def load_camera_definitions():
+    ### CAMERA DEFINITIONS
 
-# Robot camera has:
-# FOV_H = 93.*math.pi()/180.
-# FOV_V = 70.*math.pi()/180.
+    # Robot camera has:
+    # FOV_H = 93.*math.pi()/180.
+    # FOV_V = 70.*math.pi()/180.
 
-# Create fake camera (based on USB webcam params)
-fx = 810.
-fy = 810.
-cx = 320.
-cy = 240.
+    # Create fake camera (based on USB webcam params)
+    fx = 810.
+    fy = 810.
+    cx = 320.
+    cy = 240.
 
-# Define a web_cam
-web_cam_int = CameraIntrinsics()
-web_cam_int.camera_matrix = np.asarray([[fx, 0, cx], [0, fy, cy], [0, 0, 1]])
-web_cam_int.dist_coeffs = np.zeros((5, 1))
+    # Define a web_cam
+    web_cam_int = CameraIntrinsics()
+    web_cam_int.camera_matrix = np.asarray([[fx, 0, cx], [0, fy, cy],
+                                            [0, 0, 1]])
+    web_cam_int.dist_coeffs = np.zeros((5, 1))
 
-web_cam_ext = CameraExtrinsics()
-# Camera rotation from robot x,y,z to opencv (z, -x, -y)
-web_cam_ext.R = np.array([[0., 0., 1.], [-1, 0, 0], [0, -1., 0]])
-web_cam_ext.T = np.array([0., 0., 0.])
+    web_cam_ext = CameraExtrinsics()
+    # Camera rotation from robot x,y,z to opencv (z, -x, -y)
+    # This is extrinsics for the turret camera
+    # camera pose relative to center, base of the turret
+    # TODO<Jim>: Need to implement per-camera calibration, like with intrinsics
+    camera_pitch = 34.0 * np.pi / 180.0
+    camera_pitch_matrix = np.matrix(
+        [[np.cos(camera_pitch), 0.0, -np.sin(camera_pitch)], [0.0, 1.0, 0.0],
+         [np.sin(camera_pitch), 0.0,
+          np.cos(camera_pitch)]])
+    web_cam_ext.R = np.array(
+        camera_pitch_matrix *
+        np.matrix([[0., 0., 1.], [-1, 0, 0], [0, -1., 0]]))
+    #web_cam_ext.T = np.array([0., 0., 0.])
+    web_cam_ext.T = np.array([2.0 * 0.0254, -6.0 * 0.0254, 41.0 * 0.0254])
+    fixed_ext = CameraExtrinsics()
+    fixed_ext.R = np.array([[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0],
+                            [0.0, 0.0, 1.0]])
+    fixed_ext.T = np.array([0.0, 0.0, 0.0])
 
-web_cam_params = CameraParameters()
-web_cam_params.camera_int = web_cam_int
-web_cam_params.camera_ext = web_cam_ext
+    web_cam_params = CameraParameters()
+    web_cam_params.camera_int = web_cam_int
+    # Fixed extrinsics are for the turret, which is centered on the robot and
+    # pointed straight backwards.
+    web_cam_params.camera_ext = fixed_ext
+    web_cam_params.turret_ext = web_cam_ext
 
-camera_list = []
+    camera_list = []
 
-for team_number in (971, 7971, 8971, 9971):
-    for node_name in ("pi0", "pi1", "pi2", "pi3", "pi4"):
-        camera_base = copy.deepcopy(web_cam_params)
-        camera_base.node_name = node_name
-        camera_base.team_number = team_number
-        camera_list.append(camera_base)
+    # TODO<Jim>: Should probably make this a dict to make replacing easier
+    for team_number in (971, 7971, 8971, 9971):
+        for node_name in ("pi0", "pi1", "pi2", "pi3", "pi4", "pi5"):
+            camera_base = copy.deepcopy(web_cam_params)
+            camera_base.node_name = node_name
+            camera_base.team_number = team_number
+            camera_list.append(camera_base)
+
+    dir_name = dtd.bazel_name_fix('calib_files')
+    for filename in os.listdir(dir_name):
+        if "cam-calib-int" in filename and filename.endswith(".json"):
+            # Extract intrinsics from file
+            fn_split = filename.split("_")
+            hostname_split = fn_split[1].split("-")
+            if hostname_split[0] == "pi":
+                team_number = int(hostname_split[1])
+                node_name = hostname_split[0] + hostname_split[2]
+
+            calib_file = open(dir_name + "/" + filename, 'r')
+            calib_dict = json.loads(calib_file.read())
+            hostname = np.asarray(calib_dict["hostname"])
+            camera_matrix = np.asarray(calib_dict["camera_matrix"])
+            dist_coeffs = np.asarray(calib_dict["dist_coeffs"])
+
+            # Look for match, and replace camera_intrinsics
+            for camera_calib in camera_list:
+                if camera_calib.node_name == node_name and camera_calib.team_number == team_number:
+                    glog.info("Found calib for %s, team #%d" %
+                              (node_name, team_number))
+                    camera_calib.camera_int.camera_matrix = copy.copy(
+                        camera_matrix)
+                    camera_calib.camera_int.dist_coeffs = copy.copy(
+                        dist_coeffs)
+
+    return camera_list
diff --git a/y2020/vision/tools/python_code/camera_definition_test.py b/y2020/vision/tools/python_code/camera_definition_test.py
index 732dbb8..f157ba3 100644
--- a/y2020/vision/tools/python_code/camera_definition_test.py
+++ b/y2020/vision/tools/python_code/camera_definition_test.py
@@ -2,26 +2,9 @@
 import math
 import numpy as np
 
-
-class CameraIntrinsics:
-    def __init__(self):
-        self.camera_matrix = []
-        self.dist_coeffs = []
-
-
-class CameraExtrinsics:
-    def __init__(self):
-        self.R = []
-        self.T = []
-
-
-class CameraParameters:
-    def __init__(self):
-        self.camera_int = CameraIntrinsics()
-        self.camera_ext = CameraExtrinsics()
-        self.node_name = ""
-        self.team_number = -1
-
+from y2020.vision.tools.python_code.camera_definition import (CameraIntrinsics,
+                                                              CameraExtrinsics,
+                                                              CameraParameters)
 
 ### CAMERA DEFINITIONS
 
@@ -56,6 +39,6 @@
         camera_base = copy.deepcopy(web_cam_params)
         camera_base.node_name = node_name
         camera_base.team_number = team_number
-        camera_base.camera_ext.T = np.asarray(
-            np.float32([i + 1, i + 1, i + 1]))
+        camera_base.camera_ext.T = np.asarray(np.float32([i + 1, i + 1,
+                                                          i + 1]))
         camera_list.append(camera_base)
diff --git a/y2020/vision/tools/python_code/define_training_data.py b/y2020/vision/tools/python_code/define_training_data.py
index 8116fb7..76e73da 100644
--- a/y2020/vision/tools/python_code/define_training_data.py
+++ b/y2020/vision/tools/python_code/define_training_data.py
@@ -244,6 +244,18 @@
     return img
 
 
+def bazel_name_fix(filename):
+    ret_name = filename
+    try:
+        from bazel_tools.tools.python.runfiles import runfiles
+        r = runfiles.Create()
+        ret_name = r.Rlocation('org_frc971/y2020/vision/tools/python_code/' + filename)
+    except:
+        pass
+
+    return ret_name
+
+
 def sample_define_polygon_usage():
     image = cv2.imread("test_images/train_power_port_red.png")
 
diff --git a/y2020/vision/tools/python_code/image_match_test.py b/y2020/vision/tools/python_code/image_match_test.py
index 455bc30..8d16104 100644
--- a/y2020/vision/tools/python_code/image_match_test.py
+++ b/y2020/vision/tools/python_code/image_match_test.py
@@ -10,8 +10,9 @@
 
 ### DEFINITIONS
 target_definition.USE_BAZEL = False
+camera_definition.USE_BAZEL = False
 target_list = target_definition.compute_target_definition()
-camera_list = camera_definition.camera_list
+camera_list = camera_definition.load_camera_definitions()
 
 # For now, just use the first one
 camera_params = camera_list[0]
@@ -29,12 +30,14 @@
     'test_images/test_raspi3_sample.jpg',  #7
     'test_images/test_VR_sample1.png',  #8
     'test_images/train_loading_bay_blue.png',  #9
-    'test_images/train_loading_bay_red.png'  #10
+    'test_images/train_loading_bay_red.png',  #10
+    'test_images/pi-7971-3_test_image.png',  #11
+    'sample_images/capture-2020-02-13-16-40-07.png',
 ]
 
 training_image_index = 0
 # TODO: Should add argParser here to select this
-query_image_index = 0  # Use -1 to use camera capture; otherwise index above list
+query_image_index = 12  # Use -1 to use camera capture; otherwise index above list
 
 ##### Let's get to work!
 
@@ -162,8 +165,6 @@
         for m in good_matches:
             src_pts_3d.append(target_list[i].keypoint_list_3d[m.trainIdx])
             pt = query_keypoint_lists[0][m.queryIdx].pt
-            print("Color at ", pt, " is ", query_images[0][int(pt[1])][int(
-                pt[0])])
             query_images[0] = cv2.circle(
                 query_images[0], (int(pt[0]), int(pt[1])), 5, (0, 255, 0), 3)
 
diff --git a/y2020/vision/tools/python_code/image_stream.py b/y2020/vision/tools/python_code/image_stream.py
new file mode 100644
index 0000000..2cd5ac7
--- /dev/null
+++ b/y2020/vision/tools/python_code/image_stream.py
@@ -0,0 +1,34 @@
+import cv2
+import datetime
+# Open the device at the ID X for /dev/videoX
+CAMERA_INDEX = 0
+cap = cv2.VideoCapture(CAMERA_INDEX)
+
+#Check whether user selected camera is opened successfully.
+if not (cap.isOpened()):
+    print("Could not open video device /dev/video%d" % CAMERA_INDEX)
+    quit()
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = cap.read()
+
+    exp = cap.get(cv2.CAP_PROP_EXPOSURE)
+    #print("Exposure:", exp)
+    # Display the resulting frame
+    cv2.imshow('preview', frame)
+
+    #Waits for a user input to capture image or quit the application
+    keystroke = cv2.waitKey(1)
+
+    if keystroke & 0xFF == ord('q'):
+        break
+    elif keystroke & 0xFF == ord('c'):
+        image_name = datetime.datetime.today().strftime(
+            "capture-%b-%d-%Y-%H-%M-%S.png")
+        print("Capturing image as %s" % image_name)
+        cv2.imwrite(image_name, frame)
+
+# When everything's done, release the capture
+cap.release()
+cv2.destroyAllWindows()
diff --git a/y2020/vision/tools/python_code/load_sift_training.py b/y2020/vision/tools/python_code/load_sift_training.py
index 0ce70b7..a21a06f 100644
--- a/y2020/vision/tools/python_code/load_sift_training.py
+++ b/y2020/vision/tools/python_code/load_sift_training.py
@@ -27,6 +27,19 @@
     return output_list
 
 
+def list_to_transformation_matrix(values, fbb):
+    """Puts a list of values into an FBB TransformationMatrix."""
+
+    TransformationMatrix.TransformationMatrixStartDataVector(fbb, len(values))
+    for n in reversed(values):
+        fbb.PrependFloat32(n)
+    list_offset = fbb.EndVector(len(values))
+
+    TransformationMatrix.TransformationMatrixStart(fbb)
+    TransformationMatrix.TransformationMatrixAddData(fbb, list_offset)
+    return TransformationMatrix.TransformationMatrixEnd(fbb)
+
+
 def main():
 
     target_data_list = None
@@ -50,7 +63,7 @@
         import camera_definition
         import target_definition
         target_data_list = target_definition.compute_target_definition()
-        camera_calib_list = camera_definition.camera_list
+        camera_calib_list = camera_definition.load_camera_definitions()
 
     glog.info("Writing file to ", output_path)
 
@@ -138,18 +151,15 @@
     for camera_calib in camera_calib_list:
         fixed_extrinsics_list = rot_and_trans_to_list(
             camera_calib.camera_ext.R, camera_calib.camera_ext.T)
-        TransformationMatrix.TransformationMatrixStartDataVector(
-            fbb, len(fixed_extrinsics_list))
-        for n in reversed(fixed_extrinsics_list):
-            fbb.PrependFloat32(n)
-        fixed_extrinsics_data_offset = fbb.EndVector(
-            len(fixed_extrinsics_list))
+        fixed_extrinsics_vector = list_to_transformation_matrix(
+            fixed_extrinsics_list, fbb)
 
-        TransformationMatrix.TransformationMatrixStart(fbb)
-        TransformationMatrix.TransformationMatrixAddData(
-            fbb, fixed_extrinsics_data_offset)
-        fixed_extrinsics_vector = TransformationMatrix.TransformationMatrixEnd(
-            fbb)
+        turret_extrinsics_vector = None
+        if camera_calib.turret_ext is not None:
+            turret_extrinsics_list = rot_and_trans_to_list(
+                camera_calib.turret_ext.R, camera_calib.turret_ext.T)
+            turret_extrinsics_vector = list_to_transformation_matrix(
+                turret_extrinsics_list, fbb)
 
         # TODO: Need to add in distortion coefficients here
         # For now, just send camera paramter matrix (fx, fy, cx, cy)
@@ -179,6 +189,9 @@
             fbb, dist_coeffs_vector)
         CameraCalibration.CameraCalibrationAddFixedExtrinsics(
             fbb, fixed_extrinsics_vector)
+        if turret_extrinsics_vector is not None:
+            CameraCalibration.CameraCalibrationAddTurretExtrinsics(
+                fbb, turret_extrinsics_vector)
         camera_calibration_vector.append(
             CameraCalibration.CameraCalibrationEnd(fbb))
 
diff --git a/y2020/vision/tools/python_code/target_definition.py b/y2020/vision/tools/python_code/target_definition.py
index fb2f03a..6080ac2 100644
--- a/y2020/vision/tools/python_code/target_definition.py
+++ b/y2020/vision/tools/python_code/target_definition.py
@@ -12,31 +12,16 @@
 # TODO<Jim>: Allow command-line setting of logging level
 glog.setLevel("WARN")
 global VISUALIZE_KEYPOINTS
-global USE_BAZEL
-USE_BAZEL = True
 VISUALIZE_KEYPOINTS = False
 
 # For now, just have a 32 pixel radius, based on original training image
 target_radius_default = 32.
 
 
-def bazel_name_fix(filename):
-    ret_name = filename
-    if USE_BAZEL:
-        ret_name = 'org_frc971/y2020/vision/tools/python_code/' + filename
-
-    return ret_name
-
-
 class TargetData:
     def __init__(self, filename):
-        self.image_filename = filename
+        self.image_filename = dtd.bazel_name_fix(filename)
         # Load an image (will come in as a 1-element list)
-        if USE_BAZEL:
-            from bazel_tools.tools.python.runfiles import runfiles
-            r = runfiles.Create()
-            self.image_filename = r.Rlocation(
-                bazel_name_fix(self.image_filename))
         self.image = tam.load_images([self.image_filename])[0]
         self.polygon_list = []
         self.polygon_list_3d = []
@@ -90,7 +75,7 @@
         return point_list_3d
 
 
-def compute_target_definition():
+def load_training_data():
     ############################################################
     # TARGET DEFINITIONS
     ############################################################
@@ -121,12 +106,82 @@
     power_port_target_height = (
         power_port_total_height + power_port_bottom_wing_height) / 2.
 
+    ### Cafeteria target definition
+    inch_to_meter = 0.0254
+    c_power_port_total_height = (79.5 + 39.5) * inch_to_meter
+    c_power_port_edge_y = 1.089
+    c_power_port_width = 4.0 * 12 * inch_to_meter
+    c_power_port_bottom_wing_height = 79.5 * inch_to_meter
+    c_power_port_wing_width = 47.5 * inch_to_meter
+    c_power_port_white_marker_z = (79.5 - 19.5) * inch_to_meter
+
+    # Pick the target center location at halfway between top and bottom of the top panel
+    c_power_port_target_height = (
+        power_port_total_height + power_port_bottom_wing_height) / 2.
+
+    ###
+    ### Cafe power port
+    ###
+
+    # Create the reference "ideal" image
+    ideal_power_port_cafe = TargetData(
+        'test_images/train_cafeteria-2020-02-13-16-27-25.png')
+
+    # Start at lower left corner, and work around clockwise
+    # These are taken by manually finding the points in gimp for this image
+    power_port_cafe_main_panel_polygon_points_2d = [(271, 456), (278, 394),
+                                                    (135, 382), (286, 294),
+                                                    (389, 311), (397,
+                                                                 403), (401,
+                                                                        458)]
+
+    # These are "virtual" 3D points based on the expected geometry
+    power_port_cafe_main_panel_polygon_points_3d = [
+        (field_length / 2., -c_power_port_edge_y,
+         c_power_port_white_marker_z), (field_length / 2.,
+                                        -c_power_port_edge_y,
+                                        c_power_port_bottom_wing_height),
+        (field_length / 2., -c_power_port_edge_y + c_power_port_wing_width,
+         c_power_port_bottom_wing_height), (field_length / 2.,
+                                            -c_power_port_edge_y,
+                                            c_power_port_total_height),
+        (field_length / 2., -c_power_port_edge_y - c_power_port_width,
+         c_power_port_total_height),
+        (field_length / 2., -c_power_port_edge_y - c_power_port_width,
+         c_power_port_bottom_wing_height),
+        (field_length / 2., -c_power_port_edge_y - c_power_port_width,
+         c_power_port_white_marker_z)
+    ]
+
+    # Populate the cafe power port
+    ideal_power_port_cafe.polygon_list.append(
+        power_port_cafe_main_panel_polygon_points_2d)
+    ideal_power_port_cafe.polygon_list_3d.append(
+        power_port_cafe_main_panel_polygon_points_3d)
+
+    # Location of target.  Rotation is pointing in -x direction
+    ideal_power_port_cafe.target_rotation = np.identity(3, np.double)
+    ideal_power_port_cafe.target_position = np.array([
+        field_length / 2., -c_power_port_edge_y - c_power_port_width / 2.,
+        c_power_port_target_height
+    ])
+    ideal_power_port_cafe.target_point_2d = np.float32([[340, 350]]).reshape(
+        -1, 1, 2)  # train_cafeteria-2020-02-13-16-27-25.png
+
+    ideal_target_list.append(ideal_power_port_cafe)
+    training_target_power_port_cafe = TargetData(
+        'test_images/train_cafeteria-2020-02-13-16-27-25.png')
+    training_target_power_port_cafe.target_rotation = ideal_power_port_cafe.target_rotation
+    training_target_power_port_cafe.target_position = ideal_power_port_cafe.target_position
+    training_target_power_port_cafe.target_radius = target_radius_default
+    training_target_list.append(training_target_power_port_cafe)
+
     ###
     ### Red Power Port
     ###
 
     # Create the reference "ideal" image
-    ideal_power_port_red = TargetData('test_images/train_power_port_red.png')
+    ideal_power_port_red = TargetData('test_images/ideal_power_port_red.png')
 
     # Start at lower left corner, and work around clockwise
     # These are taken by manually finding the points in gimp for this image
@@ -188,7 +243,7 @@
     # and entering the pixel values from the target center for each image.
     # These are currently only used for visualization of the target
     ideal_power_port_red.target_point_2d = np.float32([[570, 192]]).reshape(
-        -1, 1, 2)  # train_power_port_red.png
+        -1, 1, 2)  # ideal_power_port_red.png
     # np.float32([[305, 97]]).reshape(-1, 1, 2),  #train_power_port_red_webcam.png
 
     # Add the ideal 3D target to our list
@@ -196,6 +251,7 @@
     # And add the training image we'll actually use to the training list
     training_target_power_port_red = TargetData(
         'test_images/train_power_port_red_webcam.png')
+    #'test_images/train_power_port_red_pi-7971-3.png')
     training_target_power_port_red.target_rotation = ideal_power_port_red.target_rotation
     training_target_power_port_red.target_position = ideal_power_port_red.target_position
     training_target_power_port_red.target_radius = target_radius_default
@@ -206,7 +262,7 @@
     ### Red Loading Bay
     ###
 
-    ideal_loading_bay_red = TargetData('test_images/train_loading_bay_red.png')
+    ideal_loading_bay_red = TargetData('test_images/ideal_loading_bay_red.png')
 
     # Start at lower left corner, and work around clockwise
     # These are taken by manually finding the points in gimp for this image
@@ -233,7 +289,7 @@
         loading_bay_height / 2.
     ])
     ideal_loading_bay_red.target_point_2d = np.float32([[366, 236]]).reshape(
-        -1, 1, 2)  # train_loading_bay_red.png
+        -1, 1, 2)  # ideal_loading_bay_red.png
 
     ideal_target_list.append(ideal_loading_bay_red)
     training_target_loading_bay_red = TargetData(
@@ -247,7 +303,7 @@
     ### Blue Power Port
     ###
 
-    ideal_power_port_blue = TargetData('test_images/train_power_port_blue.png')
+    ideal_power_port_blue = TargetData('test_images/ideal_power_port_blue.png')
 
     # Start at lower left corner, and work around clockwise
     # These are taken by manually finding the points in gimp for this image
@@ -299,22 +355,24 @@
         power_port_target_height
     ])
     ideal_power_port_blue.target_point_2d = np.float32([[567, 180]]).reshape(
-        -1, 1, 2)  # train_power_port_blue.png
+        -1, 1, 2)  # ideal_power_port_blue.png
 
-    ideal_target_list.append(ideal_power_port_blue)
+    #### TEMPORARILY DISABLING the BLUE POWER PORT target
+    #ideal_target_list.append(ideal_power_port_blue)
     training_target_power_port_blue = TargetData(
         'test_images/train_power_port_blue.png')
     training_target_power_port_blue.target_rotation = ideal_power_port_blue.target_rotation
     training_target_power_port_blue.target_position = ideal_power_port_blue.target_position
     training_target_power_port_blue.target_radius = target_radius_default
-    training_target_list.append(training_target_power_port_blue)
+    #### TEMPORARILY DISABLING the BLUE POWER PORT target
+    #training_target_list.append(training_target_power_port_blue)
 
     ###
     ### Blue Loading Bay
     ###
 
     ideal_loading_bay_blue = TargetData(
-        'test_images/train_loading_bay_blue.png')
+        'test_images/ideal_loading_bay_blue.png')
 
     # Start at lower left corner, and work around clockwise
     # These are taken by manually finding the points in gimp for this image
@@ -343,7 +401,7 @@
         loading_bay_height / 2.
     ])
     ideal_loading_bay_blue.target_point_2d = np.float32([[366, 236]]).reshape(
-        -1, 1, 2)  # train_loading_bay_blue.png
+        -1, 1, 2)  # ideal_loading_bay_blue.png
 
     ideal_target_list.append(ideal_loading_bay_blue)
     training_target_loading_bay_blue = TargetData(
@@ -353,11 +411,17 @@
     training_target_loading_bay_blue.target_radius = target_radius_default
     training_target_list.append(training_target_loading_bay_blue)
 
+    return ideal_target_list, training_target_list
+
+
+def compute_target_definition():
+    ideal_target_list, training_target_list = load_training_data()
+
     # Create feature extractor
     feature_extractor = tam.load_feature_extractor()
 
     # Use webcam parameters for now
-    camera_params = camera_definition.web_cam_params
+    camera_params = camera_definition.load_camera_definitions()[0]
 
     for ideal_target in ideal_target_list:
         glog.info(
@@ -523,20 +587,10 @@
         help="Whether to visualize the results",
         default=False,
         action='store_true')
-    ap.add_argument(
-        "-n",
-        "--no_bazel",
-        help="Don't run using Bazel",
-        default=True,
-        action='store_false')
     args = vars(ap.parse_args())
 
     VISUALIZE_KEYPOINTS = args["visualize"]
     if args["visualize"]:
         glog.info("Visualizing results")
 
-    USE_BAZEL = args["no_bazel"]
-    if args["no_bazel"]:
-        glog.info("Running on command line (no Bazel)")
-
     compute_target_definition()
diff --git a/y2020/vision/tools/python_code/test_images/ideal_loading_bay_blue.png b/y2020/vision/tools/python_code/test_images/ideal_loading_bay_blue.png
new file mode 100644
index 0000000..c3c0aea
--- /dev/null
+++ b/y2020/vision/tools/python_code/test_images/ideal_loading_bay_blue.png
Binary files differ
diff --git a/y2020/vision/tools/python_code/test_images/ideal_loading_bay_red.png b/y2020/vision/tools/python_code/test_images/ideal_loading_bay_red.png
new file mode 100644
index 0000000..42091a6
--- /dev/null
+++ b/y2020/vision/tools/python_code/test_images/ideal_loading_bay_red.png
Binary files differ
diff --git a/y2020/vision/tools/python_code/test_images/ideal_power_port_blue.png b/y2020/vision/tools/python_code/test_images/ideal_power_port_blue.png
new file mode 100644
index 0000000..a3a7597
--- /dev/null
+++ b/y2020/vision/tools/python_code/test_images/ideal_power_port_blue.png
Binary files differ
diff --git a/y2020/vision/tools/python_code/test_images/ideal_power_port_red.png b/y2020/vision/tools/python_code/test_images/ideal_power_port_red.png
new file mode 100644
index 0000000..9d2f0bf
--- /dev/null
+++ b/y2020/vision/tools/python_code/test_images/ideal_power_port_red.png
Binary files differ
diff --git a/y2020/vision/tools/python_code/test_images/train_cafeteria-2020-02-13-16-27-25.png b/y2020/vision/tools/python_code/test_images/train_cafeteria-2020-02-13-16-27-25.png
new file mode 100644
index 0000000..be67176
--- /dev/null
+++ b/y2020/vision/tools/python_code/test_images/train_cafeteria-2020-02-13-16-27-25.png
Binary files differ
diff --git a/y2020/vision/viewer.cc b/y2020/vision/viewer.cc
index be9b980..08409b2 100644
--- a/y2020/vision/viewer.cc
+++ b/y2020/vision/viewer.cc
@@ -1,3 +1,4 @@
+#include <map>
 #include <opencv2/calib3d.hpp>
 #include <opencv2/features2d.hpp>
 #include <opencv2/highgui/highgui.hpp>
@@ -5,6 +6,8 @@
 
 #include "aos/events/shm_event_loop.h"
 #include "aos/init.h"
+#include "aos/time/time.h"
+#include "y2020/vision/sift/sift_generated.h"
 #include "y2020/vision/vision_generated.h"
 
 DEFINE_string(config, "config.json", "Path to the config file to use.");
@@ -14,23 +17,66 @@
 namespace {
 
 void ViewerMain() {
+  struct TargetData {
+    float x;
+    float y;
+    float radius;
+  };
+
+  std::map<int64_t, TargetData> target_data_map;
+
   aos::FlatbufferDetachedBuffer<aos::Configuration> config =
       aos::configuration::ReadConfig(FLAGS_config);
 
   aos::ShmEventLoop event_loop(&config.message());
 
-  event_loop.MakeWatcher("/camera", [](const CameraImage &image) {
-    cv::Mat image_mat(image.rows(), image.cols(), CV_8U);
-    CHECK(image_mat.isContinuous());
-    const int number_pixels = image.rows() * image.cols();
-    for (int i = 0; i < number_pixels; ++i) {
-      reinterpret_cast<uint8_t *>(image_mat.data)[i] =
-          image.data()->data()[i * 2];
-    }
+  event_loop.MakeWatcher(
+      "/camera", [&target_data_map](const CameraImage &image) {
+        // Create color image:
+        cv::Mat image_color_mat(cv::Size(image.cols(), image.rows()), CV_8UC2,
+                                (void *)image.data()->data());
+        cv::Mat rgb_image(cv::Size(image.cols(), image.rows()), CV_8UC3);
+        cv::cvtColor(image_color_mat, rgb_image, CV_YUV2BGR_YUYV);
 
-    cv::imshow("Display", image_mat);
-    cv::waitKey(1);
-  });
+        unsigned long timestamp = image.monotonic_timestamp_ns();
+        auto target_it = target_data_map.find(timestamp);
+        if (target_it != target_data_map.end()) {
+          float x = target_it->second.x;
+          float y = target_it->second.y;
+          float radius = target_it->second.radius;
+          cv::circle(rgb_image, cv::Point2f(x, y), radius,
+                     cv::Scalar(0, 255, 0), 5);
+        }
+
+        cv::imshow("Display", rgb_image);
+        int keystroke = cv::waitKey(1);
+        if ((keystroke & 0xFF) == static_cast<int>('c')) {
+          // Convert again, to get clean image
+          cv::cvtColor(image_color_mat, rgb_image, CV_YUV2BGR_YUYV);
+          std::stringstream name;
+          name << "capture-" << aos::realtime_clock::now() << ".png";
+          cv::imwrite(name.str(), rgb_image);
+          LOG(INFO) << "Saved image file: " << name.str();
+        } else if ((keystroke & 0xFF) == static_cast<int>('q')) {
+          exit(0);
+        }
+      });
+
+  event_loop.MakeWatcher(
+      "/camera", [&target_data_map](const sift::ImageMatchResult &match) {
+        int64_t timestamp = match.image_monotonic_timestamp_ns();
+        if (match.camera_poses() != NULL && match.camera_poses()->size() > 0) {
+          LOG(INFO) << "Got match!\n";
+          TargetData target_data = {
+              match.camera_poses()->Get(0)->query_target_point_x(),
+              match.camera_poses()->Get(0)->query_target_point_y(),
+              match.camera_poses()->Get(0)->query_target_point_radius()};
+          target_data_map[timestamp] = target_data;
+          while (target_data_map.size() > 10u) {
+            target_data_map.erase(target_data_map.begin());
+          }
+        }
+      });
 
   event_loop.Run();
 }
diff --git a/y2020/vision/viewer_replay.cc b/y2020/vision/viewer_replay.cc
index c81796a..82ab11a 100644
--- a/y2020/vision/viewer_replay.cc
+++ b/y2020/vision/viewer_replay.cc
@@ -11,6 +11,8 @@
 DEFINE_string(config, "y2020/config.json", "Path to the config file to use.");
 DEFINE_string(logfile, "", "Path to the log file to use.");
 DEFINE_string(node, "pi1", "Node name to replay.");
+DEFINE_string(image_save_prefix, "/tmp/img",
+              "Prefix to use for saving images from the logfile.");
 
 namespace frc971 {
 namespace vision {
@@ -31,7 +33,8 @@
   std::unique_ptr<aos::EventLoop> event_loop =
       reader.event_loop_factory()->MakeEventLoop("player", node);
 
-  event_loop->MakeWatcher("/camera", [](const CameraImage &image) {
+  int image_count = 0;
+  event_loop->MakeWatcher("/camera", [&image_count](const CameraImage &image) {
     cv::Mat image_mat(image.rows(), image.cols(), CV_8U);
     CHECK(image_mat.isContinuous());
     const int number_pixels = image.rows() * image.cols();
@@ -41,6 +44,10 @@
     }
 
     cv::imshow("Display", image_mat);
+    if (!FLAGS_image_save_prefix.empty()) {
+      cv::imwrite("/tmp/img" + std::to_string(image_count++) + ".png",
+                  image_mat);
+    }
     cv::waitKey(1);
   });
 
diff --git a/y2020/www/BUILD b/y2020/www/BUILD
index 6b27c66..a8b0c67 100644
--- a/y2020/www/BUILD
+++ b/y2020/www/BUILD
@@ -26,6 +26,7 @@
     deps = [
         "//aos/network/www:proxy",
         "//y2020/vision/sift:sift_ts_fbs",
+        "//frc971/control_loops/drivetrain:drivetrain_status_ts_fbs",
     ],
 )
 
diff --git a/y2020/www/field_handler.ts b/y2020/www/field_handler.ts
index 0d2ea34..6ec1afb 100644
--- a/y2020/www/field_handler.ts
+++ b/y2020/www/field_handler.ts
@@ -1,9 +1,11 @@
-import {Configuration, Channel} from 'aos/configuration_generated';
-import {Connection} from 'aos/network/www/proxy';
+import {Channel, Configuration} from 'aos/configuration_generated';
 import {Connect} from 'aos/network/connect_generated';
-import {FIELD_LENGTH, FIELD_WIDTH, FT_TO_M, IN_TO_M} from './constants';
+import {Connection} from 'aos/network/www/proxy';
+import {Status as DrivetrainStatus} from 'frc971/control_loops/drivetrain/drivetrain_status_generated';
 import {ImageMatchResult} from 'y2020/vision/sift/sift_generated'
 
+import {FIELD_LENGTH, FIELD_WIDTH, FT_TO_M, IN_TO_M} from './constants';
+
 // (0,0) is field center, +X is toward red DS
 const FIELD_SIDE_Y = FIELD_WIDTH / 2;
 const FIELD_EDGE_X = FIELD_LENGTH / 2;
@@ -45,6 +47,9 @@
 const TARGET_ZONE_WIDTH = 48 * IN_TO_M;
 const LOADING_ZONE_WIDTH = 60 * IN_TO_M;
 
+const ROBOT_WIDTH = 28 * IN_TO_M;
+const ROBOT_LENGTH = 30 * IN_TO_M;
+
 /**
  * All the messages that are required to display camera information on the field.
  * Messages not readable on the server node are ignored.
@@ -70,11 +75,16 @@
     name: '/pi5/camera',
     type: 'frc971.vision.sift.ImageMatchResult',
   },
+  {
+    name: '/drivetrain',
+    type: 'frc971.control_loops.drivetrain.Status',
+  },
 ];
 
 export class FieldHandler {
   private canvas = document.createElement('canvas');
-  private imageMatchResult :ImageMatchResult|null = null
+  private imageMatchResult: ImageMatchResult|null = null;
+  private drivetrainStatus: DrivetrianStatus|null = null;
 
   constructor(private readonly connection: Connection) {
     document.body.appendChild(this.canvas);
@@ -85,6 +95,9 @@
     this.connection.addHandler(ImageMatchResult.getFullyQualifiedName(), (res) => {
       this.handleImageMatchResult(res);
     });
+    this.connection.addHandler(DrivetrainStatus.getFullyQualifiedName(), (data) => {
+      this.handleDrivetrainStatus(data);
+    });
   }
 
   private handleImageMatchResult(data: Uint8Array): void {
@@ -92,6 +105,11 @@
     this.imageMatchResult = ImageMatchResult.getRootAsImageMatchResult(fbBuffer);
   }
 
+  private handleDrivetrainStatus(data: Uint8Array): void {
+    const fbBuffer = new flatbuffers.ByteBuffer(data);
+    this.drivetrainStatus = DrivetrainStatus.getRootAsStatus(fbBuffer);
+  }
+
   private sendConnect(): void {
     const builder = new flatbuffers.Builder(512);
     const channels: flatbuffers.Offset[] = [];
@@ -199,6 +217,20 @@
     ctx.restore();
   }
 
+  drawRobot(x: number, y: number, theta: number): void {
+    const ctx = this.canvas.getContext('2d');
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate(theta);
+    ctx.rect(-ROBOT_LENGTH / 2, -ROBOT_WIDTH / 2, ROBOT_LENGTH, ROBOT_WIDTH);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(0, 0);
+    ctx.lineTo(ROBOT_LENGTH / 2, 0);
+    ctx.stroke();
+    ctx.restore();
+  }
+
   draw(): void  {
     this.reset();
     this.drawField();
@@ -209,11 +241,19 @@
         const mat = pose.fieldToCamera();
         const x = mat.data(3);
         const y = mat.data(7);
-        this.drawCamera(x, y, 0);
-        console.log(x, y);
+        const theta = Math.atan2(
+            -mat.data(8),
+            Math.sqrt(Math.pow(mat.data(9), 2) + Math.pow(mat.data(10), 2)));
+        this.drawCamera(x, y, theta);
       }
     }
 
+    if (this.drivetrainStatus) {
+      this.drawRobot(
+          this.drivetrainStatus.x(), this.drivetrainStatus.y(),
+          this.drivetrainStatus.theta());
+    }
+
     window.requestAnimationFrame(() => this.draw());
   }
 
diff --git a/y2020/y2020.json b/y2020/y2020.json
index b40ac87..285a23d 100644
--- a/y2020/y2020.json
+++ b/y2020/y2020.json
@@ -46,7 +46,7 @@
       "name": "/aos/roborio",
       "type": "aos.logging.LogMessageFbs",
       "source_node": "roborio",
-      "frequency": 200,
+      "frequency": 400,
       "num_senders": 20
     },
     {
@@ -293,7 +293,24 @@
       "source_node": "roborio",
       "frequency": 200,
       "max_size": 2000,
-      "num_senders": 2
+      "num_senders": 2,
+      "destination_nodes": [
+        {
+          "name": "pi1",
+          "priority": 5,
+          "time_to_live": 5000000
+        },
+        {
+          "name": "pi2",
+          "priority": 5,
+          "time_to_live": 5000000
+        },
+        {
+          "name": "pi3",
+          "priority": 5,
+          "time_to_live": 5000000
+        }
+      ]
     },
     {
       "name": "/drivetrain",
@@ -325,6 +342,8 @@
       "name": "/pi1/camera",
       "type": "frc971.vision.sift.ImageMatchResult",
       "source_node": "pi1",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_node": "roborio",
       "frequency": 25,
       "max_size": 10000,
       "destination_nodes": [
@@ -361,6 +380,8 @@
       "name": "/pi2/camera",
       "type": "frc971.vision.sift.ImageMatchResult",
       "source_node": "pi2",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_node": "roborio",
       "frequency": 25,
       "max_size": 300000,
       "destination_nodes": [
@@ -397,6 +418,8 @@
       "name": "/pi3/camera",
       "type": "frc971.vision.sift.ImageMatchResult",
       "source_node": "pi3",
+      "logger": "LOCAL_AND_REMOTE_LOGGER",
+      "logger_node": "roborio",
       "frequency": 25,
       "max_size": 10000,
       "destination_nodes": [