From dea17cd93d8b3efc52279c6e75b72c5873956eb0 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 21 Jun 2024 16:23:46 +0200
Subject: [PATCH 01/80] Setting up gRPC and proto messages

---
 .idea/misc.xml                                |   1 -
 pom.xml                                       |  58 +++++++
 .../prlprg/server/ClientHandleException.java  |  15 --
 .../java/org/prlprg/server/ClientHandler.java | 120 --------------
 .../server/ClientParseViolationException.java |  18 ---
 .../java/org/prlprg/server/ClientState.java   |  35 -----
 .../server/ClientStateViolationException.java |  21 ---
 .../org/prlprg/server/ReqRepHandlers.java     |  57 -------
 src/main/java/org/prlprg/server/Server.java   | 147 +-----------------
 .../server/SomeClientHandleException.java     |  14 --
 src/main/proto/messages.proto                 |  29 ++++
 11 files changed, 89 insertions(+), 426 deletions(-)
 delete mode 100644 src/main/java/org/prlprg/server/ClientHandleException.java
 delete mode 100644 src/main/java/org/prlprg/server/ClientHandler.java
 delete mode 100644 src/main/java/org/prlprg/server/ClientParseViolationException.java
 delete mode 100644 src/main/java/org/prlprg/server/ClientState.java
 delete mode 100644 src/main/java/org/prlprg/server/ClientStateViolationException.java
 delete mode 100644 src/main/java/org/prlprg/server/ReqRepHandlers.java
 delete mode 100644 src/main/java/org/prlprg/server/SomeClientHandleException.java
 create mode 100644 src/main/proto/messages.proto

diff --git a/.idea/misc.xml b/.idea/misc.xml
index 9cd683e93..4aa75026e 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -7,7 +7,6 @@
         <option value="$PROJECT_DIR$/pom.xml" />
       </list>
     </option>
-    <option name="workspaceImportForciblyTurnedOn" value="true" />
   </component>
   <component name="NullableNotNullManager">
     <option name="myDefaultNullable" value="javax.annotation.Nullable" />
diff --git a/pom.xml b/pom.xml
index ff0249201..9757247b7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,6 +15,8 @@
     <maven.compiler.source>21</maven.compiler.source>
     <maven.compiler.target>${maven.compiler.source}</maven.compiler.target>
     <pmdVersion>7.0.0-rc4</pmdVersion>
+    <protobuf.version>3.6.1</protobuf.version>
+    <grpc.version>1.64.0</grpc.version>
   </properties>
 
   <dependencyManagement>
@@ -37,6 +39,35 @@
       <artifactId>jeromq</artifactId>
       <version>0.5.4</version>
     </dependency>
+    <!-- gRPC, RPC communication -->
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <version>${grpc.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+      <version>${grpc.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+      <version>${grpc.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.protobuf</groupId>
+      <artifactId>protobuf-java</artifactId>
+      <version>${protobuf.version}</version>
+    </dependency>
+    <dependency>
+      <!-- necessary for Java 9+ -->
+      <groupId>org.apache.tomcat</groupId>
+      <artifactId>annotations-api</artifactId>
+      <version>6.0.53</version>
+      <scope>provided</scope>
+    </dependency>
+
     <!-- Guava, utilities -->
     <dependency>
       <groupId>com.google.guava</groupId>
@@ -69,6 +100,25 @@
     <!-- Snapshots aren't test resources, because we have to write to them, so we access them
                                  at their actual locations (bundled are overridden on recompile). -->
     <plugins>
+      <!-- code gen for protobuf -->
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>com.google.protobuf:protoc:3.25.1:exe:${os.detected.classifier}</protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.64.0:exe:${os.detected.classifier}</pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
       <!-- git-build-hook, install git hooks when you run any maven command so you don't forget -->
       <plugin>
         <groupId>com.rudikershaw.gitbuildhook</groupId>
@@ -275,5 +325,13 @@
         <!-- automatically runs on `test` (and `verify` because `verify` invokes `test`) -->
       </plugin>
     </plugins>
+    <extensions>
+      <!-- For gRPC/protobuf-->
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
   </build>
 </project>
diff --git a/src/main/java/org/prlprg/server/ClientHandleException.java b/src/main/java/org/prlprg/server/ClientHandleException.java
deleted file mode 100644
index 50d9ad43f..000000000
--- a/src/main/java/org/prlprg/server/ClientHandleException.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.prlprg.server;
-
-/**
- * An exception a background thread got when processing a client request. This exception is checked
- * while the underlying exception may not be.
- */
-public final class ClientHandleException extends Exception {
-  /** Client's address. */
-  public final String address;
-
-  ClientHandleException(String address, Throwable cause) {
-    super("Handler/thread for client " + address + " crashed", cause);
-    this.address = address;
-  }
-}
diff --git a/src/main/java/org/prlprg/server/ClientHandler.java b/src/main/java/org/prlprg/server/ClientHandler.java
deleted file mode 100644
index ecbd4d9b6..000000000
--- a/src/main/java/org/prlprg/server/ClientHandler.java
+++ /dev/null
@@ -1,120 +0,0 @@
-package org.prlprg.server;
-
-import javax.annotation.Nullable;
-import org.zeromq.ZMQ;
-import org.zeromq.ZMQ.Error;
-import org.zeromq.ZMQException;
-
-/**
- * Manages communication between the server and a particular client. Contains the client's socket,
- * thread, and {@link ClientState}.
- *
- * <p>This class doesn't implement {@link AutoCloseable}; if you want to close this, close the
- * socket. The reason is that the socket may close on its own, so we have to handle that case
- * anyways, and don't want two separate ways to close.
- */
-final class ClientHandler {
-  private final String address;
-  private final ZMQ.Socket socket;
-  private final Thread thread;
-  private @Nullable Throwable exception = null;
-  // When the socket closes, we aren't made aware until we handle its next message and get null or
-  // an exception.
-  private boolean isDefinitelyClosed = false;
-  private final ClientState state = new ClientState();
-
-  /**
-   * <b>This will immediately start handling client requests on a background thread immediately.</b>
-   *
-   * <p>As specified in the class description, to close this (and stop the thread), close the
-   * socket.
-   *
-   * @param address The address of the socket. It must resolve to the same address as {@code
-   *     socket.getLastEndpoint()}, however the actual text may be different (e.g. localhost vs
-   *     127.0.0.1) which is why we need to pass it explicitly (because otherwise {@link
-   *     Server#unbind} won't work).
-   */
-  ClientHandler(String address, ZMQ.Socket socket) {
-    this.address = address;
-    this.socket = socket;
-    this.thread =
-        new Thread(
-            () -> {
-              try {
-                while (true) {
-                  var message = socket.recvStr();
-                  if (message == null) {
-                    // Socket closed
-                    isDefinitelyClosed = true;
-                    break;
-                  }
-                  var response = ReqRepHandlers.handle(state, message);
-                  if (response != null) {
-                    socket.send(response);
-                  }
-                }
-              } catch (ZMQException e) {
-                close();
-                var error = Error.findByCode(e.getErrorCode());
-                switch (error) {
-                    // Currently assume these are normal
-                  case Error.ECONNABORTED:
-                  case Error.ETERM:
-                    System.out.println("ClientState-" + address() + " closed with " + error);
-                    break;
-                  default:
-                    exception = e;
-                    throw e;
-                }
-              } catch (Throwable e) {
-                close();
-                exception = e;
-                throw e;
-              }
-            });
-    thread.setName("ClientState-" + address());
-    thread.start();
-  }
-
-  /** The address the client is connected to. */
-  String address() {
-    return address;
-  }
-
-  /**
-   * Close the underlying socket, which makes the thread stop on next communication (if it's doing
-   * something it won't stop immediately).
-   *
-   * <p>If the socket is already closed, the behavior of this method is undefined.
-   */
-  void close() {
-    if (isDefinitelyClosed) {
-      throw new IllegalStateException("Socket already closed");
-    }
-    isDefinitelyClosed = true;
-    socket.close();
-  }
-
-  /**
-   * Throws a {@link ClientHandleException} if the client disconnected because it got an exception.
-   */
-  void checkForException() throws ClientHandleException {
-    if (exception != null) {
-      throw new ClientHandleException(address(), exception);
-    }
-  }
-
-  /**
-   * Waits for the client to disconnect and the socket to close on its own.
-   *
-   * @throws ClientHandleException if a client disconnected because it got an exception.
-   */
-  void waitForDisconnect() throws ClientHandleException {
-    try {
-      thread.join();
-    } catch (InterruptedException e) {
-      throw new RuntimeException(e);
-    }
-    checkForException();
-  }
-}
diff --git a/src/main/java/org/prlprg/server/ClientParseViolationException.java b/src/main/java/org/prlprg/server/ClientParseViolationException.java
deleted file mode 100644
index 0bbc14463..000000000
--- a/src/main/java/org/prlprg/server/ClientParseViolationException.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.prlprg.server;
-
-/** The client sent a malformed message. */
-public final class ClientParseViolationException extends IllegalStateException {
-  @SuppressWarnings("unused")
-  ClientParseViolationException(String message) {
-    super(message);
-  }
-
-  ClientParseViolationException(Throwable cause) {
-    super(cause);
-  }
-
-  @SuppressWarnings("unused")
-  ClientParseViolationException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}
diff --git a/src/main/java/org/prlprg/server/ClientState.java b/src/main/java/org/prlprg/server/ClientState.java
deleted file mode 100644
index 363fa0a60..000000000
--- a/src/main/java/org/prlprg/server/ClientState.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package org.prlprg.server;
-
-import javax.annotation.Nullable;
-import org.prlprg.RVersion;
-
-/**
- * State for a client stored on the server visible to {@link ReqRepHandlers}.
- *
- * <p>Doesn't include the socket and client thread, that's the role of {@link ClientHandler}.
- */
-final class ClientState {
-  private record Init(RVersion version) {}
-
-  private @Nullable Init init;
-
-  ClientState() {}
-
-  void init(RVersion version) {
-    if (init != null) {
-      throw new ClientStateViolationException("Client already initialized");
-    }
-    init = new Init(version);
-  }
-
-  RVersion version() {
-    return init().version;
-  }
-
-  private Init init() {
-    if (init == null) {
-      throw new ClientStateViolationException("Client not initialized");
-    }
-    return init;
-  }
-}
diff --git a/src/main/java/org/prlprg/server/ClientStateViolationException.java b/src/main/java/org/prlprg/server/ClientStateViolationException.java
deleted file mode 100644
index 6e0fdbbb9..000000000
--- a/src/main/java/org/prlprg/server/ClientStateViolationException.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.prlprg.server;
-
-/**
- * The client sent a message or data the server wasn't expecting in its state. e.g. client
- * initializes itself twice.
- */
-public final class ClientStateViolationException extends IllegalStateException {
-  ClientStateViolationException(String message) {
-    super(message);
-  }
-
-  @SuppressWarnings("unused")
-  ClientStateViolationException(Throwable cause) {
-    super(cause);
-  }
-
-  @SuppressWarnings("unused")
-  ClientStateViolationException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}
diff --git a/src/main/java/org/prlprg/server/ReqRepHandlers.java b/src/main/java/org/prlprg/server/ReqRepHandlers.java
deleted file mode 100644
index 8a9861594..000000000
--- a/src/main/java/org/prlprg/server/ReqRepHandlers.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package org.prlprg.server;
-
-import javax.annotation.Nullable;
-import org.prlprg.RVersion;
-import org.prlprg.util.NotImplementedError;
-
-/**
- * Functions for each initial request the client can make. They take the initial request body as
- * params (as well as client state), and return the final response (or void if there are none). If a
- * request is more complicated than a simple function (e.g. server can respond with "more
- * information needed" and then wait until the client sends more), the function will also take a
- * {@link Mediator} to send intermediate responses and handle intermediate requests (possibly out-
- * of-order, we're not sure what kinds of communicatio we'll need yet).
- *
- * <p>The specific handlers are actually all private, because this class's interface has the method
- * which handles a generic initial request, parsing and dispatching to the specific handler.
- */
-final class ReqRepHandlers {
-  private static final String SIMPLE_ACK = "";
-
-  /**
-   * Handle an initial request (not intermediate request in a request chain) from the client.
-   *
-   * <p>Apparetly ZMQ needs every request to have some response. If this returns null, it already
-   * send a response. If this only needs to do a simple ACK, it will return the empty string.
-   */
-  // TODO: Add GenericMediator which can create all other mediators which we'll do depending on the
-  //  request type. GenericMediator will have a reference to the ClientHandler's socket and thread
-  //  so it can send and receive subsequect requests,
-  static @Nullable String handle(ClientState state, String request) {
-    // TODO: Parse request type and the rest of the data, create specific mediator if necessary,
-    //  dispatch to the specific handler, and encode the response.
-    if (request.equals("Hello, server!")) {
-      throw new ClientStateViolationException("bad message");
-    }
-    if (request.startsWith("Proper init ")) {
-      RVersion rVersion;
-      try {
-        rVersion = RVersion.parse(request.substring("Proper init ".length()));
-      } catch (IllegalArgumentException e) {
-        throw new ClientParseViolationException(e);
-      }
-      init(state, rVersion);
-      return SIMPLE_ACK;
-    }
-    if (request.startsWith("Something which returns null so IntelliJ doesn't complain")) {
-      return null;
-    }
-    throw new NotImplementedError();
-  }
-
-  // region specific handlers
-  private static void init(ClientState state, RVersion rVersion) {
-    state.init(rVersion);
-  }
-  // endregion
-}
diff --git a/src/main/java/org/prlprg/server/Server.java b/src/main/java/org/prlprg/server/Server.java
index 4d997fa8f..b899518ad 100644
--- a/src/main/java/org/prlprg/server/Server.java
+++ b/src/main/java/org/prlprg/server/Server.java
@@ -1,155 +1,12 @@
 package org.prlprg.server;
 
-import com.google.common.collect.ImmutableList;
 import java.io.Closeable;
-import java.util.Set;
-import org.prlprg.util.WeakHashSet;
-import org.zeromq.SocketType;
-import org.zeromq.ZContext;
 
 /**
  * An instance of the compile server which communicates with clients.
  *
  * <p>All methods to send and receive data are here so they're easy to find.
  *
- * @implNote The current plan is for the server's interface to be exclusive to the main thread,
- *     which includes adding sockets and closing. The server spawns separate threads for each client
- *     to wait and handle their requests, and the clients threads may spawn child threads for
- *     specific multi-part requests (although first the clients need to be multi- threaded).
+ * @implNote This uses gRPC.
  */
-public final class Server implements Closeable {
-  // TODO: Make this an environment variable, but we should have some centralized configuration
-  //   static class with all environment variables
-  private static final int IO_THREADS = 1;
-
-  private final Thread mainThread = Thread.currentThread();
-  private final ZContext context = new ZContext(IO_THREADS);
-  // Assume that ClientHandlers get garbage collected when their sockets and threads close.
-  // This doesn't mean all client handlers in the set are open, don't assume so.
-  private final Set<ClientHandler> clients = new WeakHashSet<>();
-
-  /** Creates a new server. */
-  public Server() {}
-
-  /**
-   * Binds the server to the given address so a client can connect. Currently, we only allow one
-   * client per address, but a server can bind to multiple addresses.
-   *
-   * <p>This method must be called from the thread the server was created on.
-   *
-   * @param address The address to bind to, e.g. "tcp://*:5555".
-   */
-  public void bind(String address) {
-    requireMainThread("bind");
-
-    var socket = context.createSocket(SocketType.REP);
-    var isBound = socket.bind(address);
-    // Does ZMQ ever return false without throwing? If so, we need to handle
-    assert isBound;
-
-    clients.add(new ClientHandler(address, socket));
-  }
-
-  /**
-   * Unbinds the server from the given address so, if a client is connected, it will disconnect. If
-   * the client socket was closed, this method may or may not throw {@link
-   * IllegalArgumentException}.
-   *
-   * <p>If the client was once but already no longer connected, the behavior of this method is
-   * undefined.
-   *
-   * <p>This method must be called from the thread the server was created on.
-   *
-   * @param address The address to unbind from, e.g. "tcp://*:5555".
-   * @throws IllegalArgumentException If no client is bound to the given address.
-   */
-  public void unbind(String address) {
-    requireMainThread("unbind");
-
-    for (var client : clients) {
-      if (client.address().equals(address)) {
-        client.close();
-        return;
-      }
-    }
-    throw new IllegalArgumentException("No client bound to " + address);
-  }
-
-  /**
-   * Throws a {@link SomeClientHandleException} if any client disconnected because it got an
-   * exception.
-   *
-   * <p>This method must be called from the thread the server was created on.
-   */
-  void checkForAnyException() throws SomeClientHandleException {
-    requireMainThread("checkForAnyException");
-
-    var exceptionsBuilder =
-        ImmutableList.<ClientHandleException>builderWithExpectedSize(clients.size());
-
-    for (var client : clients) {
-      try {
-        client.checkForException();
-      } catch (ClientHandleException e) {
-        exceptionsBuilder.add(e);
-      }
-    }
-
-    var exceptions = exceptionsBuilder.build();
-    if (!exceptions.isEmpty()) {
-      throw new SomeClientHandleException(exceptions);
-    }
-  }
-
-  /**
-   * Waits for all clients to disconnect.
-   *
-   * <p>This method must be called from the thread the server was created on.
-   *
-   * @throws SomeClientHandleException If any client disconnected because it got an exception.
-   */
-  public void waitForAllDisconnect() throws SomeClientHandleException {
-    requireMainThread("waitForAllDisconnect");
-
-    var exceptionsBuilder =
-        ImmutableList.<ClientHandleException>builderWithExpectedSize(clients.size());
-
-    for (var client : clients) {
-      try {
-        client.waitForDisconnect();
-      } catch (ClientHandleException e) {
-        exceptionsBuilder.add(e);
-      }
-    }
-
-    var exceptions = exceptionsBuilder.build();
-    if (!exceptions.isEmpty()) {
-      throw new SomeClientHandleException(exceptions);
-    }
-  }
-
-  /**
-   * Closes the server, disconnecting all clients.
-   *
-   * <p>This method must be called from the thread the server was created on.
-   */
-  @Override
-  public void close() {
-    requireMainThread("close");
-
-    // Probably handled by context but anyways
-    if (context.isClosed()) {
-      throw new IllegalStateException("Server already closed");
-    }
-
-    context.close();
-    // Sockets will disconnect, and client handlers will stop their threads, automatically
-  }
-
-  private void requireMainThread(String method) {
-    if (Thread.currentThread() != mainThread) {
-      throw new IllegalStateException(
-          "Method " + method + " must be called from the thread the server was created on");
-    }
-  }
-}
+public final class Server implements Closeable {}
diff --git a/src/main/java/org/prlprg/server/SomeClientHandleException.java b/src/main/java/org/prlprg/server/SomeClientHandleException.java
deleted file mode 100644
index 40c7fb27d..000000000
--- a/src/main/java/org/prlprg/server/SomeClientHandleException.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.prlprg.server;
-
-import com.google.common.collect.ImmutableList;
-
-/** If any client threads closed because of an exception, the server will throw this. */
-public final class SomeClientHandleException extends Exception {
-  /** The exceptions that caused the client threads to close. */
-  public final ImmutableList<ClientHandleException> clientExceptions;
-
-  SomeClientHandleException(ImmutableList<ClientHandleException> clientExceptions) {
-    super("Some client handlers/threads crashed, see the client exceptions for details.");
-    this.clientExceptions = clientExceptions;
-  }
-}
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
new file mode 100644
index 000000000..6e7550aff
--- /dev/null
+++ b/src/main/proto/messages.proto
@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+option java_package = "org.prlprg.server";
+
+message Function {
+  optional string package = 1;
+  string name = 2;
+}
+
+enum TypeFeedback {
+  SCALAR = 0;
+  VECTOR = 1;// Add more of the type feedback
+}
+
+message CompileRequest {
+  bytes hash = 1;
+  optional Function function = 2;
+  optional bytes body = 3;
+  repeated TypeFeedback type_feedback = 4;
+  // should we rather use a map parameter -> type feedback?
+  // Indeed if the types keep the same but parameters are swapped
+  // in the parameter list, we should recompile the function
+}
+
+message CompileResponse {
+  bytes hash = 1;
+  optional bytes native_code = 2;
+  optional bytes constant_pool = 3;
+}
\ No newline at end of file

From d5bcb7afd73bb9c85fdbf10af7f698b99e370e52 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 25 Jun 2024 14:10:00 +0200
Subject: [PATCH 02/80] Remove tests that depended on ZeroMQ

---
 pom.xml                                       |   2 +-
 src/main/java/org/prlprg/server/Server.java   |   6 +-
 .../org/prlprg/server/ClientStateTests.java   |  16 +--
 .../java/org/prlprg/server/ServerTests.java   | 101 +-----------------
 4 files changed, 8 insertions(+), 117 deletions(-)

diff --git a/pom.xml b/pom.xml
index 9757247b7..b3eda7e90 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,7 +15,7 @@
     <maven.compiler.source>21</maven.compiler.source>
     <maven.compiler.target>${maven.compiler.source}</maven.compiler.target>
     <pmdVersion>7.0.0-rc4</pmdVersion>
-    <protobuf.version>3.6.1</protobuf.version>
+    <protobuf.version>3.25.3</protobuf.version>
     <grpc.version>1.64.0</grpc.version>
   </properties>
 
diff --git a/src/main/java/org/prlprg/server/Server.java b/src/main/java/org/prlprg/server/Server.java
index b899518ad..1621c79d7 100644
--- a/src/main/java/org/prlprg/server/Server.java
+++ b/src/main/java/org/prlprg/server/Server.java
@@ -1,6 +1,7 @@
 package org.prlprg.server;
 
 import java.io.Closeable;
+import java.io.IOException;
 
 /**
  * An instance of the compile server which communicates with clients.
@@ -9,4 +10,7 @@
  *
  * @implNote This uses gRPC.
  */
-public final class Server implements Closeable {}
+public final class Server implements Closeable {
+  @Override
+  public void close() throws IOException {}
+}
diff --git a/src/test/java/org/prlprg/server/ClientStateTests.java b/src/test/java/org/prlprg/server/ClientStateTests.java
index 825522aab..53f326940 100644
--- a/src/test/java/org/prlprg/server/ClientStateTests.java
+++ b/src/test/java/org/prlprg/server/ClientStateTests.java
@@ -1,17 +1,3 @@
 package org.prlprg.server;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-import org.junit.jupiter.api.Test;
-import org.prlprg.RVersion;
-
-public class ClientStateTests {
-  @Test
-  public void testClientState() {
-    var clientState = new ClientState();
-    assertThrows(ClientStateViolationException.class, clientState::version);
-    clientState.init(RVersion.LATEST_AWARE);
-    assertEquals(RVersion.LATEST_AWARE, clientState.version());
-  }
-}
+public class ClientStateTests {}
diff --git a/src/test/java/org/prlprg/server/ServerTests.java b/src/test/java/org/prlprg/server/ServerTests.java
index 0dc4fc208..ff66ec7de 100644
--- a/src/test/java/org/prlprg/server/ServerTests.java
+++ b/src/test/java/org/prlprg/server/ServerTests.java
@@ -1,102 +1,3 @@
 package org.prlprg.server;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-import java.io.IOException;
-import java.net.ServerSocket;
-import org.junit.jupiter.api.Test;
-import org.zeromq.SocketType;
-import org.zeromq.ZSocket;
-
-public class ServerTests {
-  @Test
-  public void testEmptyServer() throws SomeClientHandleException {
-    var server = new Server();
-    server.waitForAllDisconnect();
-    server.close();
-  }
-
-  @Test
-  public void testServerImmediatelyUnbind() throws SomeClientHandleException {
-    int port = getUnusedPort();
-
-    var server = new Server();
-    server.bind("tcp://localhost:" + port);
-
-    var aClient = new ZSocket(SocketType.REQ);
-    aClient.connect("tcp://localhost:" + port);
-
-    server.unbind("tcp://localhost:" + port);
-
-    // Client won't send
-    aClient.sendStringUtf8("Hello, server!");
-
-    // These will do nothing
-    server.checkForAnyException();
-    server.waitForAllDisconnect();
-    // Close should still work
-    server.close();
-  }
-
-  @Test
-  public void testServerWithABadClient() {
-    int port = getUnusedPort();
-
-    var server = new Server();
-    server.bind("tcp://localhost:" + port);
-
-    var aClient = new ZSocket(SocketType.REQ);
-    aClient.connect("tcp://localhost:" + port);
-
-    // This isn't a valid message, so it will trigger an exception in the background thread
-    aClient.sendStringUtf8("Hello, server!");
-
-    // Which will propogate when we join
-    assertThrows(SomeClientHandleException.class, server::waitForAllDisconnect);
-    // And check exceptions (this must be called after join or the client handler may have not yet
-    // thrown anything)
-    assertThrows(SomeClientHandleException.class, server::checkForAnyException);
-
-    // Close should still work
-    server.close();
-  }
-
-  @Test
-  public void testServerWithAGoodClientOnlyInit() throws SomeClientHandleException {
-    int port = getUnusedPort();
-
-    var server = new Server();
-    server.bind("tcp://localhost:" + port);
-
-    var aClient = new ZSocket(SocketType.REQ);
-    aClient.connect("tcp://localhost:" + port);
-
-    // This is a valid message and will initialize the client
-    aClient.sendStringUtf8("Proper init 1.23.45");
-    assertEquals("", aClient.receiveStringUtf8());
-
-    // So this will do nothing
-    server.checkForAnyException();
-
-    // This is now invalid because the client has already been initialized
-    aClient.sendStringUtf8("Proper init 1.23.45");
-    // If we try receiveStringUtf8 here it will hang forever. Even though we closed the socket on
-    // the server end (and even we unbind), that's what ZMQ seems to do.
-
-    // So this will throw an exception
-    assertThrows(SomeClientHandleException.class, server::waitForAllDisconnect);
-
-    // This should work normally, as always
-    server.close();
-  }
-
-  private int getUnusedPort() {
-    // From https://stackoverflow.com/questions/2675362/how-to-find-an-available-port
-    try (var socket = new ServerSocket(0)) {
-      return socket.getLocalPort();
-    } catch (IOException e) {
-      throw new RuntimeException("Failed to find an unused port", e);
-    }
-  }
-}
+public class ServerTests {}

From 2bc9e64744df76124d7a3c87ee2e02ae9b904465 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 2 Jul 2024 16:59:52 +0200
Subject: [PATCH 03/80] Routes + flexible messages to get updated facts about a
 function for the server

---
 src/main/proto/messages.proto | 64 +++++++++++++++++++++++++++++------
 src/main/proto/routes.proto   | 10 ++++++
 2 files changed, 64 insertions(+), 10 deletions(-)
 create mode 100644 src/main/proto/routes.proto

diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 6e7550aff..f117dafd2 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -2,21 +2,53 @@ syntax = "proto3";
 
 option java_package = "org.prlprg.server";
 
+// Error handling
+// grpc already has a way to handle errors
+// Status message: https://grpc.github.io/grpc-java/javadoc/io/grpc/Status.html
+
+message Version {
+  int32 major = 1;
+  int32 minor = 2;
+  int32 patch = 3;
+}
+
+message Package {
+  string name = 1;
+  Version version = 2;
+  optional bytes hash = 3;
+  repeated Function functions = 4;
+}
+
+message InitRequest {
+  Version Rsh_version = 1;
+  Version R_version = 2;
+  string platform = 3;
+  repeated Package packages = 4;
+}
+
+message InitResponse {}
+
 message Function {
-  optional string package = 1;
-  string name = 2;
+  optional string package = 1;// There can be only one version of a package loaded at a time
+  string name = 2; //What if it is a closure passed to a HOF?
+  optional bytes body = 3;
+  optional bytes hash = 4;
 }
 
 enum TypeFeedback {
   SCALAR = 0;
-  VECTOR = 1;// Add more of the type feedback
+  VECTOR = 1;// Add more types
+}
+enum Tier {
+  BASELINE = 0;
+  OPTIMIZED = 1;
 }
 
 message CompileRequest {
-  bytes hash = 1;
-  optional Function function = 2;
-  optional bytes body = 3;
-  repeated TypeFeedback type_feedback = 4;
+  Function function = 2;// Add package version
+  optional Tier tier = 4;//if not defined, let the compile server decide
+  optional int32 optimization_level = 5;// if not defined, the server decides
+  repeated TypeFeedback type_feedback = 6;// n arguments + return type
   // should we rather use a map parameter -> type feedback?
   // Indeed if the types keep the same but parameters are swapped
   // in the parameter list, we should recompile the function
@@ -24,6 +56,18 @@ message CompileRequest {
 
 message CompileResponse {
   bytes hash = 1;
-  optional bytes native_code = 2;
-  optional bytes constant_pool = 3;
-}
\ No newline at end of file
+  Tier tier = 2;
+  optional bytes native_code = 3;
+  optional bytes constant_pool = 4;
+}
+
+message FactRequest {
+  Function function = 1;
+  string factName = 2;// Make it an enum when we know what kind of facts we would like to know about a function
+}
+
+message Fact {
+  Function function = 1;// which function is that about
+  string factName = 2;
+  string factValue = 3;// Make it more typed when we know more about what kind of facts we want
+}
diff --git a/src/main/proto/routes.proto b/src/main/proto/routes.proto
new file mode 100644
index 000000000..25b505369
--- /dev/null
+++ b/src/main/proto/routes.proto
@@ -0,0 +1,10 @@
+syntax = "proto3";
+
+option java_package = "org.prlprg.server";
+
+import "messages.proto";
+
+service CompileService {
+  rpc Compile(CompileRequest) returns (CompileResponse) {}
+  rpc Init(InitRequest) returns (InitResponse) {}
+}
\ No newline at end of file

From 51f212d1aad03475efdf7d1a8a22a4861d8aebcd Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 9 Jul 2024 16:31:25 +0200
Subject: [PATCH 04/80] Adding contexts

---
 src/main/proto/messages.proto | 36 ++++++++++++++++++++++++++++-------
 src/main/proto/routes.proto   |  2 ++
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index f117dafd2..65ceff921 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -28,6 +28,8 @@ message InitRequest {
 
 message InitResponse {}
 
+message Empty {}
+
 message Function {
   optional string package = 1;// There can be only one version of a package loaded at a time
   string name = 2; //What if it is a closure passed to a HOF?
@@ -35,9 +37,28 @@ message Function {
   optional bytes hash = 4;
 }
 
-enum TypeFeedback {
-  SCALAR = 0;
-  VECTOR = 1;// Add more types
+message CallContext {
+  bool args_statically_matched = 1;
+  bool correct_number_of_args = 2;
+  bool correct_order_of_args = 3;
+  bool no_missing_args = 4;
+}
+
+message ArgumentContext {
+  bool eager = 1;
+  bool reflection = 2;
+  bool object = 3;
+  optional Type type = 4;
+}
+
+message Context {
+  CallContext call_context = 1;
+  repeated ArgumentContext argument_context = 2;
+}
+
+enum Type {
+  INTEGER = 0;
+  REAL = 1;// Add more types
 }
 enum Tier {
   BASELINE = 0;
@@ -48,10 +69,7 @@ message CompileRequest {
   Function function = 2;// Add package version
   optional Tier tier = 4;//if not defined, let the compile server decide
   optional int32 optimization_level = 5;// if not defined, the server decides
-  repeated TypeFeedback type_feedback = 6;// n arguments + return type
-  // should we rather use a map parameter -> type feedback?
-  // Indeed if the types keep the same but parameters are swapped
-  // in the parameter list, we should recompile the function
+  optional Context context = 6;
 }
 
 message CompileResponse {
@@ -61,6 +79,10 @@ message CompileResponse {
   optional bytes constant_pool = 4;
 }
 
+message ContextRequest {
+  Function function = 1;
+}
+
 message FactRequest {
   Function function = 1;
   string factName = 2;// Make it an enum when we know what kind of facts we would like to know about a function
diff --git a/src/main/proto/routes.proto b/src/main/proto/routes.proto
index 25b505369..5802e10a2 100644
--- a/src/main/proto/routes.proto
+++ b/src/main/proto/routes.proto
@@ -7,4 +7,6 @@ import "messages.proto";
 service CompileService {
   rpc Compile(CompileRequest) returns (CompileResponse) {}
   rpc Init(InitRequest) returns (InitResponse) {}
+  rpc GetContext(ContextRequest) returns (Context) {}
+  rpc LoadPackage(Package) returns (Empty) {}
 }
\ No newline at end of file

From 48fcc0c88fe78953dd4f81df6c76d524b350ac46 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 10 Jul 2024 15:56:01 +0200
Subject: [PATCH 05/80] TYpeFeedback message

---
 src/main/proto/messages.proto | 38 +++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 65ceff921..376539d14 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -60,11 +60,49 @@ enum Type {
   INTEGER = 0;
   REAL = 1;// Add more types
 }
+
 enum Tier {
   BASELINE = 0;
   OPTIMIZED = 1;
 }
 
+enum TestLattice {
+  BOTH = 0;
+  ONLY_TRUE = 1;
+  ONLY_FALSE = 2;
+  NONE = 3;
+}
+
+message TestFeedback {
+  TestLattice test_lattice = 1;
+}
+
+message CallFeedback {
+  int64 n_calls = 1;
+  bytes callee_hash = 2;
+}
+
+message ValueFeedback {
+  bool scalar = 1;
+  bool object = 2;
+  bool accessed_attributes = 3;
+  bool vectorizable = 4;
+  bool is_promise = 5;
+}
+
+
+
+message TypeFeedback {
+  message Feedback {
+    oneof feedback {
+      TestFeedback test_feedback = 1;
+      CallFeedback call_feedback = 2;
+      ValueFeedback value_feedback = 3;
+    }
+  }
+  map<int64, Feedback> types = 1;//Offset in the bytecode to the feedback
+}
+
 message CompileRequest {
   Function function = 2;// Add package version
   optional Tier tier = 4;//if not defined, let the compile server decide

From 60bfc1fc7ab78a9e35f624d6c02c8d1b86bfe969 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 10 Jul 2024 16:27:38 +0200
Subject: [PATCH 06/80] Start the compile service.

---
 .../java/org/prlprg/server/CompileServer.java | 80 +++++++++++++++++++
 src/main/java/org/prlprg/server/Server.java   | 16 ----
 src/main/proto/messages.proto                 |  9 ++-
 src/main/proto/routes.proto                   |  6 +-
 4 files changed, 90 insertions(+), 21 deletions(-)
 create mode 100644 src/main/java/org/prlprg/server/CompileServer.java
 delete mode 100644 src/main/java/org/prlprg/server/Server.java

diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
new file mode 100644
index 000000000..4599c2fc7
--- /dev/null
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -0,0 +1,80 @@
+package org.prlprg.server;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+class CompileServer {
+  private static final Logger logger = Logger.getLogger(CompileServer.class.getName());
+
+  private final int port;
+  private final Server server;
+
+  public CompileServer(int port) {
+    this.port = port;
+    this.server = ServerBuilder.forPort(port).addService(new CompileService()).build();
+  }
+
+  public void start() throws Exception {
+    server.start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread() {
+              @Override
+              public void run() {
+                // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+                System.err.println("*** shutting down gRPC server since JVM is shutting down");
+                try {
+                  CompileServer.this.stop();
+                } catch (InterruptedException e) {
+                  e.printStackTrace(System.err);
+                }
+                System.err.println("*** server shut down");
+              }
+            });
+  }
+
+  /** Stop serving requests and shutdown resources. */
+  public void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /** Await termination on the main thread since the grpc library uses daemon threads. */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    CompileServer server = new CompileServer(8980);
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  private static class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
+    @Override
+    public void compile(
+        Messages.CompileRequest request,
+        StreamObserver<Messages.CompileResponse> responseObserver) {
+      // Parse the request
+      Messages.Function function = request.getFunction();
+      Messages.Tier tier = request.getTier(); // Default is baseline
+      int optimizationLevel = request.getOptimizationLevel(); // default is 0
+      Messages.Context context = request.getContext(); // null if not provided
+
+      // Compile the code and build response
+      Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
+      // TODO
+
+      // Send the response
+      responseObserver.onNext(response.build());
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/src/main/java/org/prlprg/server/Server.java b/src/main/java/org/prlprg/server/Server.java
deleted file mode 100644
index 1621c79d7..000000000
--- a/src/main/java/org/prlprg/server/Server.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.prlprg.server;
-
-import java.io.Closeable;
-import java.io.IOException;
-
-/**
- * An instance of the compile server which communicates with clients.
- *
- * <p>All methods to send and receive data are here so they're easy to find.
- *
- * @implNote This uses gRPC.
- */
-public final class Server implements Closeable {
-  @Override
-  public void close() throws IOException {}
-}
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 376539d14..73d1c917d 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -57,13 +57,14 @@ message Context {
 }
 
 enum Type {
-  INTEGER = 0;
-  REAL = 1;// Add more types
+  ANY = 0;
+  INTEGER = 1;
+  REAL = 2;// Add more types
 }
 
 enum Tier {
-  BASELINE = 0;
-  OPTIMIZED = 1;
+  BASELINE = 0;// bytecode
+  OPTIMIZED = 1; // native code
 }
 
 enum TestLattice {
diff --git a/src/main/proto/routes.proto b/src/main/proto/routes.proto
index 5802e10a2..dd7284369 100644
--- a/src/main/proto/routes.proto
+++ b/src/main/proto/routes.proto
@@ -4,9 +4,13 @@ option java_package = "org.prlprg.server";
 
 import "messages.proto";
 
+// R sends requests to the server
 service CompileService {
   rpc Compile(CompileRequest) returns (CompileResponse) {}
   rpc Init(InitRequest) returns (InitResponse) {}
   rpc GetContext(ContextRequest) returns (Context) {}
   rpc LoadPackage(Package) returns (Empty) {}
-}
\ No newline at end of file
+}
+
+// TODO: add a request service which will be use
+// by the compile server to ask questions to R
\ No newline at end of file

From 08ee5bcd7639268e86e13592608d7537242ab9ef Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 10 Jul 2024 16:55:09 +0200
Subject: [PATCH 07/80] Skeleton of the compilation to bytecode

---
 src/main/java/org/prlprg/rds/RDSReader.java   |  5 ++++
 .../java/org/prlprg/server/CompileServer.java | 25 +++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index d2318ec9d..75aad7ba3 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -1,6 +1,7 @@
 package org.prlprg.rds;
 
 import com.google.common.collect.ImmutableList;
+import com.google.protobuf.ByteString;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.io.*;
 import java.nio.charset.Charset;
@@ -40,6 +41,10 @@ public static SEXP readStream(RSession session, InputStream input) throws IOExce
     }
   }
 
+  public static SEXP readByteString(RSession session, ByteString byteString) throws IOException {
+    return RDSReader.readStream(session, byteString.newInput());
+  }
+
   private void readHeader() throws IOException {
     var type = in.readByte();
     if (type != 'X') {
diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index 4599c2fc7..ac9430e9e 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -3,8 +3,14 @@
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
 import io.grpc.stub.StreamObserver;
+import java.io.IOException;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
+import org.prlprg.RSession;
+import org.prlprg.bc.Compiler;
+import org.prlprg.rds.RDSReader;
+import org.prlprg.sexp.CloSXP;
+import org.prlprg.sexp.SEXP;
 
 class CompileServer {
   private static final Logger logger = Logger.getLogger(CompileServer.class.getName());
@@ -71,6 +77,25 @@ public void compile(
       // Compile the code and build response
       Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
       // TODO
+      if (function.hasBody()) {
+        // TODO: we need a RSession. Create it at the level of the CompileServer class.
+        RSession session = null;
+        SEXP closure = null;
+        try {
+          closure = RDSReader.readByteString(session, function.getBody());
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+        if (closure instanceof CloSXP c) {
+          Compiler compiler = new Compiler(c, session);
+        } else {
+          // TODO: fail because we are asked to compile something which is not
+          // a closure
+        }
+      } else {
+        // We should cache the Compiler instance for that function and then
+        // retrieve it here.
+      }
 
       // Send the response
       responseObserver.onNext(response.build());

From 2cba2b99627229fc6315acd89e82103931bf8c62 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 11 Jul 2024 16:23:19 +0200
Subject: [PATCH 08/80] gRPC reflection and Rsession

---
 pom.xml                                       |  5 ++
 src/main/java/org/prlprg/bc/Compiler.java     |  2 +-
 src/main/java/org/prlprg/rds/RDSReader.java   |  2 +-
 .../java/org/prlprg/server/CompileServer.java | 26 ++++--
 .../java/org/prlprg/session/GNURSession.java  | 81 +++++++++++++++++++
 .../org/prlprg/{ => session}/RSession.java    |  2 +-
 .../java/org/prlprg/session/package-info.java | 11 +++
 src/main/proto/messages.proto                 | 25 +++---
 src/main/proto/routes.proto                   | 11 ++-
 .../org/prlprg/rsession/TestRSession.java     |  4 +-
 .../prlprg/util/AbstractGNURBasedTest.java    |  2 +-
 src/test/java/org/prlprg/util/GNUR.java       |  2 +-
 12 files changed, 147 insertions(+), 26 deletions(-)
 create mode 100644 src/main/java/org/prlprg/session/GNURSession.java
 rename src/main/java/org/prlprg/{ => session}/RSession.java (93%)
 create mode 100644 src/main/java/org/prlprg/session/package-info.java

diff --git a/pom.xml b/pom.xml
index b3eda7e90..9dc359bad 100644
--- a/pom.xml
+++ b/pom.xml
@@ -60,6 +60,11 @@
       <artifactId>protobuf-java</artifactId>
       <version>${protobuf.version}</version>
     </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-services</artifactId>
+      <version>${grpc.version}</version>
+    </dependency>
     <dependency>
       <!-- necessary for Java 9+ -->
       <groupId>org.apache.tomcat</groupId>
diff --git a/src/main/java/org/prlprg/bc/Compiler.java b/src/main/java/org/prlprg/bc/Compiler.java
index 647e64b3a..0c033c49e 100644
--- a/src/main/java/org/prlprg/bc/Compiler.java
+++ b/src/main/java/org/prlprg/bc/Compiler.java
@@ -8,8 +8,8 @@
 import java.util.function.*;
 import java.util.stream.IntStream;
 import javax.annotation.Nullable;
-import org.prlprg.RSession;
 import org.prlprg.bc.BcInstr.*;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.*;
 
 /**
diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index 75aad7ba3..be1e1f9d8 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -8,11 +8,11 @@
 import java.nio.charset.StandardCharsets;
 import java.util.*;
 import javax.annotation.Nullable;
-import org.prlprg.RSession;
 import org.prlprg.bc.Bc;
 import org.prlprg.primitive.Complex;
 import org.prlprg.primitive.Constants;
 import org.prlprg.primitive.Logical;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.*;
 import org.prlprg.util.IO;
 
diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index ac9430e9e..e7e6264e9 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -2,13 +2,17 @@
 
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
+import io.grpc.Status;
+import io.grpc.protobuf.services.ProtoReflectionService;
 import io.grpc.stub.StreamObserver;
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
-import org.prlprg.RSession;
 import org.prlprg.bc.Compiler;
 import org.prlprg.rds.RDSReader;
+import org.prlprg.session.GNURSession;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.CloSXP;
 import org.prlprg.sexp.SEXP;
 
@@ -20,7 +24,13 @@ class CompileServer {
 
   public CompileServer(int port) {
     this.port = port;
-    this.server = ServerBuilder.forPort(port).addService(new CompileService()).build();
+    this.server =
+        ServerBuilder.forPort(port)
+            .addService(new CompileService())
+            .addService(
+                ProtoReflectionService
+                    .newInstance()) // automatic discovery of all services and messages
+            .build();
   }
 
   public void start() throws Exception {
@@ -68,6 +78,7 @@ private static class CompileService extends CompileServiceGrpc.CompileServiceImp
     public void compile(
         Messages.CompileRequest request,
         StreamObserver<Messages.CompileResponse> responseObserver) {
+
       // Parse the request
       Messages.Function function = request.getFunction();
       Messages.Tier tier = request.getTier(); // Default is baseline
@@ -79,7 +90,8 @@ public void compile(
       // TODO
       if (function.hasBody()) {
         // TODO: we need a RSession. Create it at the level of the CompileServer class.
-        RSession session = null;
+        // TODO: find out the right path. Env var?
+        RSession session = new GNURSession(Path.of("path/to/R/"));
         SEXP closure = null;
         try {
           closure = RDSReader.readByteString(session, function.getBody());
@@ -89,8 +101,12 @@ public void compile(
         if (closure instanceof CloSXP c) {
           Compiler compiler = new Compiler(c, session);
         } else {
-          // TODO: fail because we are asked to compile something which is not
-          // a closure
+          // See
+          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+          // We could have more details using that:
+          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
+          responseObserver.onError(
+              Status.INTERNAL.withDescription("Not a closure").asRuntimeException());
         }
       } else {
         // We should cache the Compiler instance for that function and then
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
new file mode 100644
index 000000000..f1f2482e1
--- /dev/null
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -0,0 +1,81 @@
+package org.prlprg.session;
+
+import java.net.URI;
+import java.nio.file.Path;
+import java.util.List;
+import org.prlprg.server.Messages;
+import org.prlprg.sexp.BaseEnvSXP;
+import org.prlprg.sexp.GlobalEnvSXP;
+import org.prlprg.sexp.NamespaceEnvSXP;
+
+public class GNURSession implements RSession {
+  private URI cranMirror;
+
+  // TODO: need the path to R *and* the path to the installed packages
+  public GNURSession(Path r_dir) {
+    cranMirror = URI.create("https://cran.r-project.org");
+  }
+
+  GNURSession(Path r_dir, URI cranMirror) {
+    this(r_dir);
+    this.cranMirror = cranMirror;
+  }
+
+  public void setCranMirror(URI uri) {}
+
+  // We should also handle installation of a package from a Github repo?
+  public void loadPackage(String name, String version) {
+    // Check if package is installed and if not install it
+
+    // Load index (name.rdx) and serialized objects (name.rdb)
+    // Or rather do lazy loading like R?
+  }
+
+  private void readPackageDatabase(Path path, String packageName) {}
+
+  /**
+   * Makes it possible to load a package by providing its functions directly.
+   *
+   * <p>Note that it does not support loading the package's data, documentation, etc.
+   *
+   * @param name
+   * @param version
+   * @param functions in the package
+   */
+  public void loadPackage(String name, String version, List<Messages.Function> functions) {}
+
+  @Override
+  public NamespaceEnvSXP baseNamespace() {
+    return null;
+  }
+
+  @Override
+  public BaseEnvSXP baseEnv() {
+    return null;
+  }
+
+  @Override
+  public GlobalEnvSXP globalEnv() {
+    return null;
+  }
+
+  @Override
+  public boolean isBuiltin(String name) {
+    return false;
+  }
+
+  @Override
+  public boolean isSpecial(String name) {
+    return false;
+  }
+
+  @Override
+  public boolean isBuiltinInternal(String name) {
+    return false;
+  }
+
+  @Override
+  public NamespaceEnvSXP getNamespace(String name, String version) {
+    return null;
+  }
+}
diff --git a/src/main/java/org/prlprg/RSession.java b/src/main/java/org/prlprg/session/RSession.java
similarity index 93%
rename from src/main/java/org/prlprg/RSession.java
rename to src/main/java/org/prlprg/session/RSession.java
index fcd6ba5e6..90e524ecb 100644
--- a/src/main/java/org/prlprg/RSession.java
+++ b/src/main/java/org/prlprg/session/RSession.java
@@ -1,4 +1,4 @@
-package org.prlprg;
+package org.prlprg.session;
 
 import org.prlprg.sexp.BaseEnvSXP;
 import org.prlprg.sexp.GlobalEnvSXP;
diff --git a/src/main/java/org/prlprg/session/package-info.java b/src/main/java/org/prlprg/session/package-info.java
new file mode 100644
index 000000000..6ff4de529
--- /dev/null
+++ b/src/main/java/org/prlprg/session/package-info.java
@@ -0,0 +1,11 @@
+/**
+ * Socket setup and communication with clients (which are running an instance of R), and protocols.
+ */
+@ParametersAreNonnullByDefault
+@FieldsAreNonNullByDefault
+@ReturnTypesAreNonNullByDefault
+package org.prlprg.session;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+import org.prlprg.util.FieldsAreNonNullByDefault;
+import org.prlprg.util.ReturnTypesAreNonNullByDefault;
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 73d1c917d..2fa71340e 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -15,15 +15,16 @@ message Version {
 message Package {
   string name = 1;
   Version version = 2;
-  optional bytes hash = 3;
-  repeated Function functions = 4;
+  optional bytes hash = 3;//Hash of the whole package
+  repeated Function functions = 4;// we can send some/all of the functions (with their bodies and/or hash)
+  // What about package data? Maybe just the sysdata?
 }
 
 message InitRequest {
-  Version Rsh_version = 1;
+  Version Rsh_version = 1;// version of the compile server
   Version R_version = 2;
   string platform = 3;
-  repeated Package packages = 4;
+  repeated Package packages = 4;//Packages we are initially part of the environment (in addition to base)
 }
 
 message InitResponse {}
@@ -56,6 +57,10 @@ message Context {
   repeated ArgumentContext argument_context = 2;
 }
 
+message ContextRequest {
+  Function function = 1;
+}
+
 enum Type {
   ANY = 0;
   INTEGER = 1;
@@ -91,9 +96,8 @@ message ValueFeedback {
   bool is_promise = 5;
 }
 
-
-
 message TypeFeedback {
+  Function function = 1;
   message Feedback {
     oneof feedback {
       TestFeedback test_feedback = 1;
@@ -101,7 +105,11 @@ message TypeFeedback {
       ValueFeedback value_feedback = 3;
     }
   }
-  map<int64, Feedback> types = 1;//Offset in the bytecode to the feedback
+  map<int64, Feedback> types = 2;//Offset in the bytecode to the feedback
+}
+
+message FeedbackRequest {
+  Function function = 1;
 }
 
 message CompileRequest {
@@ -118,9 +126,6 @@ message CompileResponse {
   optional bytes constant_pool = 4;
 }
 
-message ContextRequest {
-  Function function = 1;
-}
 
 message FactRequest {
   Function function = 1;
diff --git a/src/main/proto/routes.proto b/src/main/proto/routes.proto
index dd7284369..d3292e1fc 100644
--- a/src/main/proto/routes.proto
+++ b/src/main/proto/routes.proto
@@ -4,13 +4,16 @@ option java_package = "org.prlprg.server";
 
 import "messages.proto";
 
-// R sends requests to the server
+// R sends requests to the compile server
 service CompileService {
   rpc Compile(CompileRequest) returns (CompileResponse) {}
   rpc Init(InitRequest) returns (InitResponse) {}
-  rpc GetContext(ContextRequest) returns (Context) {}
   rpc LoadPackage(Package) returns (Empty) {}
 }
 
-// TODO: add a request service which will be use
-// by the compile server to ask questions to R
\ No newline at end of file
+// Used by the compile server to ask questions to R
+service FactService {
+  rpc GetFact(FactRequest) returns (Fact) {} // Generic fact
+  rpc GetContext(ContextRequest) returns (Context) {}
+  rpc GetTypeFeedback(FeedbackRequest) returns (TypeFeedback) {}
+}
\ No newline at end of file
diff --git a/src/test/java/org/prlprg/rsession/TestRSession.java b/src/test/java/org/prlprg/rsession/TestRSession.java
index 974eed741..e4357c733 100644
--- a/src/test/java/org/prlprg/rsession/TestRSession.java
+++ b/src/test/java/org/prlprg/rsession/TestRSession.java
@@ -7,8 +7,8 @@
 import java.util.Objects;
 import java.util.Set;
 import javax.annotation.Nullable;
-import org.prlprg.RSession;
 import org.prlprg.rds.RDSReader;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.*;
 import org.prlprg.util.IO;
 
@@ -43,7 +43,7 @@ private void bootstrapBase() {
       var bindings = new HashMap<String, SEXP>(names.size());
       names.forEach(x -> bindings.put(x, SEXPs.UNBOUND_VALUE));
 
-      // 3. Create a temporary baseenv and temporart base namespace
+      // 3. Create a temporary baseenv and temporary base namespace
       baseEnv = new BaseEnvSXP(bindings);
       // the 4.3.2 should correspond to the R version that written the RDS files used in this class
       baseNamespace = new NamespaceEnvSXP("base", "4.3.2", baseEnv, bindings);
diff --git a/src/test/java/org/prlprg/util/AbstractGNURBasedTest.java b/src/test/java/org/prlprg/util/AbstractGNURBasedTest.java
index 815b861ee..ade3a8d67 100644
--- a/src/test/java/org/prlprg/util/AbstractGNURBasedTest.java
+++ b/src/test/java/org/prlprg/util/AbstractGNURBasedTest.java
@@ -5,9 +5,9 @@
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.TestInstance;
-import org.prlprg.RSession;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.rsession.TestRSession;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.SEXP;
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
diff --git a/src/test/java/org/prlprg/util/GNUR.java b/src/test/java/org/prlprg/util/GNUR.java
index b454466a2..84507f682 100644
--- a/src/test/java/org/prlprg/util/GNUR.java
+++ b/src/test/java/org/prlprg/util/GNUR.java
@@ -5,8 +5,8 @@
 import java.io.*;
 import java.util.UUID;
 import javax.annotation.concurrent.NotThreadSafe;
-import org.prlprg.RSession;
 import org.prlprg.rds.RDSReader;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.SEXP;
 
 @NotThreadSafe

From 96838e63b177887734a5b06cacd886e9f9ef8b51 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 11 Jul 2024 19:05:57 +0200
Subject: [PATCH 09/80] External test of the server

---
 src/main/java/org/prlprg/server/CompileServer.java |  6 ++++++
 src/main/proto/messages.proto                      | 11 +++++++++--
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index e7e6264e9..064d53db9 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -74,6 +74,9 @@ public static void main(String[] args) throws Exception {
   }
 
   private static class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
+
+    // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
+    // CompileService.Compile
     @Override
     public void compile(
         Messages.CompileRequest request,
@@ -85,6 +88,8 @@ public void compile(
       int optimizationLevel = request.getOptimizationLevel(); // default is 0
       Messages.Context context = request.getContext(); // null if not provided
 
+      logger.info("Received request to compile function " + function.getName());
+
       // Compile the code and build response
       Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
       // TODO
@@ -114,6 +119,7 @@ public void compile(
       }
 
       // Send the response
+      response.setTier(tier);
       responseObserver.onNext(response.build());
       responseObserver.onCompleted();
     }
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 2fa71340e..861a3e097 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -12,18 +12,26 @@ message Version {
   int32 patch = 3;
 }
 
+message PackageSource {
+ oneof source {
+    string r_mirror = 2;
+    string github_url = 3;
+  }
+}
+
 message Package {
   string name = 1;
   Version version = 2;
   optional bytes hash = 3;//Hash of the whole package
   repeated Function functions = 4;// we can send some/all of the functions (with their bodies and/or hash)
   // What about package data? Maybe just the sysdata?
+  optional PackageSource source = 5;
 }
 
 message InitRequest {
   Version Rsh_version = 1;// version of the compile server
   Version R_version = 2;
-  string platform = 3;
+  string platform = 3;//amd64, etc TODO: use an enum for the allowed platforms?
   repeated Package packages = 4;//Packages we are initially part of the environment (in addition to base)
 }
 
@@ -133,7 +141,6 @@ message FactRequest {
 }
 
 message Fact {
-  Function function = 1;// which function is that about
   string factName = 2;
   string factValue = 3;// Make it more typed when we know more about what kind of facts we want
 }

From dcdcffe533c150a0186c6b5aabf4873d8339af1b Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 12 Jul 2024 18:16:38 +0200
Subject: [PATCH 10/80] Always refer to function and packages through hashes

---
 .../java/org/prlprg/server/CompileServer.java | 28 +++++++++--
 .../java/org/prlprg/session/GNURSession.java  | 49 ++++++++++++++++---
 src/main/proto/messages.proto                 | 20 +++++---
 3 files changed, 78 insertions(+), 19 deletions(-)

diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index 064d53db9..0556ad844 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -6,13 +6,12 @@
 import io.grpc.protobuf.services.ProtoReflectionService;
 import io.grpc.stub.StreamObserver;
 import java.io.IOException;
-import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
+import javax.annotation.Nullable;
 import org.prlprg.bc.Compiler;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.session.GNURSession;
-import org.prlprg.session.RSession;
 import org.prlprg.sexp.CloSXP;
 import org.prlprg.sexp.SEXP;
 
@@ -74,6 +73,7 @@ public static void main(String[] args) throws Exception {
   }
 
   private static class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
+    private @Nullable GNURSession session = null;
 
     // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
     // CompileService.Compile
@@ -82,6 +82,11 @@ public void compile(
         Messages.CompileRequest request,
         StreamObserver<Messages.CompileResponse> responseObserver) {
 
+      if (session == null) {
+        responseObserver.onError(
+            Status.INTERNAL.withDescription("Session not initialized.").asRuntimeException());
+      }
+
       // Parse the request
       Messages.Function function = request.getFunction();
       Messages.Tier tier = request.getTier(); // Default is baseline
@@ -94,9 +99,6 @@ public void compile(
       Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
       // TODO
       if (function.hasBody()) {
-        // TODO: we need a RSession. Create it at the level of the CompileServer class.
-        // TODO: find out the right path. Env var?
-        RSession session = new GNURSession(Path.of("path/to/R/"));
         SEXP closure = null;
         try {
           closure = RDSReader.readByteString(session, function.getBody());
@@ -123,5 +125,21 @@ public void compile(
       responseObserver.onNext(response.build());
       responseObserver.onCompleted();
     }
+
+    @Override
+    public void init(
+        Messages.InitRequest request, StreamObserver<Messages.InitResponse> responseObserver) {
+
+      // Parse the request
+      Messages.Version rshVersion = request.getRshVersion();
+      Messages.Version RVersion = request.getRVersion();
+      String platform = request.getPlatform();
+
+      var packages = request.getPackageHashList();
+
+      // Look into our cache if we have the packages.
+      // Request the packages for those we do not have hashes for.
+
+    }
   }
 }
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index f1f2482e1..35f9daf2a 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -1,23 +1,37 @@
 package org.prlprg.session;
 
+import java.io.IOException;
 import java.net.URI;
 import java.nio.file.Path;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Set;
+import javax.annotation.Nullable;
+import org.prlprg.RVersion;
+import org.prlprg.rds.RDSReader;
 import org.prlprg.server.Messages;
-import org.prlprg.sexp.BaseEnvSXP;
-import org.prlprg.sexp.GlobalEnvSXP;
-import org.prlprg.sexp.NamespaceEnvSXP;
+import org.prlprg.sexp.*;
 
 public class GNURSession implements RSession {
   private URI cranMirror;
+  private org.prlprg.RVersion RVersion;
+
+  private @Nullable BaseEnvSXP baseEnvSXP = null;
+  private @Nullable NamespaceEnvSXP baseNamespace = null;
+  private @Nullable GlobalEnvSXP globalEnv = null;
+  private @Nullable Set<String> builtins = null;
+  private @Nullable Set<String> specials = null;
+  private @Nullable Set<String> builtinsInternal = null;
+  private @Nullable HashMap<String, NamespaceEnvSXP> namespaces = null;
 
   // TODO: need the path to R *and* the path to the installed packages
-  public GNURSession(Path r_dir) {
+  public GNURSession(org.prlprg.RVersion version, Path r_dir) {
     cranMirror = URI.create("https://cran.r-project.org");
+    RVersion = version;
   }
 
-  GNURSession(Path r_dir, URI cranMirror) {
-    this(r_dir);
+  public GNURSession(RVersion version, Path r_dir, URI cranMirror) {
+    this(version, r_dir);
     this.cranMirror = cranMirror;
   }
 
@@ -41,8 +55,29 @@ private void readPackageDatabase(Path path, String packageName) {}
    * @param name
    * @param version
    * @param functions in the package
+   * @return the populated environment
    */
-  public void loadPackage(String name, String version, List<Messages.Function> functions) {}
+  public EnvSXP loadPackage(String name, String version, List<Messages.Function> functions) {
+    if (name.equals("base")) {
+      throw new RuntimeException("Cannot load base namespace this way");
+    }
+    // Should the parent rather be the package namespace?
+    if (baseNamespace == null) {
+      throw new RuntimeException("Base namespace not loaded yet");
+    }
+
+    var bindings = new HashMap<String, SEXP>(functions.size());
+    functions.forEach(
+        function -> {
+          try {
+            bindings.put(
+                function.getName(), (CloSXP) RDSReader.readByteString(this, function.getBody()));
+          } catch (IOException e) {
+            throw new RuntimeException(e);
+          }
+        });
+    return new NamespaceEnvSXP(name, version, baseNamespace, bindings);
+  }
 
   @Override
   public NamespaceEnvSXP baseNamespace() {
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 861a3e097..27a5feaa5 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -22,17 +22,20 @@ message PackageSource {
 message Package {
   string name = 1;
   Version version = 2;
-  optional bytes hash = 3;//Hash of the whole package
-  repeated Function functions = 4;// we can send some/all of the functions (with their bodies and/or hash)
+  repeated bytes function_hashes = 4;
   // What about package data? Maybe just the sysdata?
-  optional PackageSource source = 5;
+  optional PackageSource source = 5;//If none, it is a base package or a local package
+}
+
+message PackageRequest {
+  bytes hash = 1;
 }
 
 message InitRequest {
   Version Rsh_version = 1;// version of the compile server
   Version R_version = 2;
   string platform = 3;//amd64, etc TODO: use an enum for the allowed platforms?
-  repeated Package packages = 4;//Packages we are initially part of the environment (in addition to base)
+  repeated bytes package_hash = 4;//Packages which are initially part of the environment (in addition to base)
 }
 
 message InitResponse {}
@@ -40,10 +43,14 @@ message InitResponse {}
 message Empty {}
 
 message Function {
-  optional string package = 1;// There can be only one version of a package loaded at a time
+  bytes package_hash = 1;
   string name = 2; //What if it is a closure passed to a HOF?
   optional bytes body = 3;
-  optional bytes hash = 4;
+  // what about the function parameters?
+}
+
+message FunctionRequest {
+  bytes hash = 1;
 }
 
 message CallContext {
@@ -105,7 +112,6 @@ message ValueFeedback {
 }
 
 message TypeFeedback {
-  Function function = 1;
   message Feedback {
     oneof feedback {
       TestFeedback test_feedback = 1;

From bd60b1e6f4583dd428595ec786220f38423caf9c Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 18 Jul 2024 16:29:19 +0200
Subject: [PATCH 11/80] Reorganize messages and add health service

---
 .../java/org/prlprg/server/CompileServer.java |   6 +
 src/main/proto/messages.proto                 | 124 ++++++++++--------
 src/main/proto/routes.proto                   |   4 +-
 3 files changed, 80 insertions(+), 54 deletions(-)

diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index 0556ad844..3de04c1d6 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -3,6 +3,8 @@
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
 import io.grpc.Status;
+import io.grpc.health.v1.HealthCheckResponse;
+import io.grpc.protobuf.services.HealthStatusManager;
 import io.grpc.protobuf.services.ProtoReflectionService;
 import io.grpc.stub.StreamObserver;
 import java.io.IOException;
@@ -20,12 +22,15 @@ class CompileServer {
 
   private final int port;
   private final Server server;
+  private HealthStatusManager health;
 
   public CompileServer(int port) {
     this.port = port;
+    this.health = new HealthStatusManager();
     this.server =
         ServerBuilder.forPort(port)
             .addService(new CompileService())
+            .addService(health.getHealthService())
             .addService(
                 ProtoReflectionService
                     .newInstance()) // automatic discovery of all services and messages
@@ -50,6 +55,7 @@ public void run() {
                 System.err.println("*** server shut down");
               }
             });
+    health.setStatus("", HealthCheckResponse.ServingStatus.SERVING);
   }
 
   /** Stop serving requests and shutdown resources. */
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 27a5feaa5..23ed0cfde 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -6,30 +6,7 @@ option java_package = "org.prlprg.server";
 // grpc already has a way to handle errors
 // Status message: https://grpc.github.io/grpc-java/javadoc/io/grpc/Status.html
 
-message Version {
-  int32 major = 1;
-  int32 minor = 2;
-  int32 patch = 3;
-}
-
-message PackageSource {
- oneof source {
-    string r_mirror = 2;
-    string github_url = 3;
-  }
-}
-
-message Package {
-  string name = 1;
-  Version version = 2;
-  repeated bytes function_hashes = 4;
-  // What about package data? Maybe just the sysdata?
-  optional PackageSource source = 5;//If none, it is a base package or a local package
-}
-
-message PackageRequest {
-  bytes hash = 1;
-}
+// Init
 
 message InitRequest {
   Version Rsh_version = 1;// version of the compile server
@@ -40,7 +17,24 @@ message InitRequest {
 
 message InitResponse {}
 
-message Empty {}
+
+// Basic messages
+
+message CompileRequest {
+  Function function = 2;// Add package version
+  optional Tier tier = 4;//if not defined, let the compile server decide
+  optional int32 optimization_level = 5;// if not defined, the server decides
+  optional Context context = 6;
+  optional Environment environment = 7;//The values of all the bindings that statically appear in the function
+}
+
+message CompileResponse {
+  bytes hash = 1;
+  Tier tier = 2;
+  optional bytes native_code = 3;
+  optional bytes constant_pool = 4;
+}
+
 
 message Function {
   bytes package_hash = 1;
@@ -53,6 +47,32 @@ message FunctionRequest {
   bytes hash = 1;
 }
 
+message Environment {
+  map<string, bytes> values = 1;//Name of the variable to a hash of the value
+}
+
+
+message ValueRequest {
+  repeated bytes hash = 1;// We can batch and ask for several values
+}
+
+message Value {
+  bytes hash = 1;
+  bytes value = 2;
+}
+message Values {
+  repeated Value values = 1;
+}
+
+message Empty {}
+
+enum Tier {
+  BASELINE = 0;// bytecode
+  OPTIMIZED = 1; // native code
+}
+
+// Context
+
 message CallContext {
   bool args_statically_matched = 1;
   bool correct_number_of_args = 2;
@@ -76,16 +96,8 @@ message ContextRequest {
   Function function = 1;
 }
 
-enum Type {
-  ANY = 0;
-  INTEGER = 1;
-  REAL = 2;// Add more types
-}
 
-enum Tier {
-  BASELINE = 0;// bytecode
-  OPTIMIZED = 1; // native code
-}
+// Feedback
 
 enum TestLattice {
   BOTH = 0;
@@ -94,6 +106,12 @@ enum TestLattice {
   NONE = 3;
 }
 
+enum Type {
+  ANY = 0;
+  INTEGER = 1;
+  REAL = 2;// Add more types
+}
+
 message TestFeedback {
   TestLattice test_lattice = 1;
 }
@@ -126,27 +144,29 @@ message FeedbackRequest {
   Function function = 1;
 }
 
-message CompileRequest {
-  Function function = 2;// Add package version
-  optional Tier tier = 4;//if not defined, let the compile server decide
-  optional int32 optimization_level = 5;// if not defined, the server decides
-  optional Context context = 6;
-}
+// Packages
 
-message CompileResponse {
-  bytes hash = 1;
-  Tier tier = 2;
-  optional bytes native_code = 3;
-  optional bytes constant_pool = 4;
+message Version {
+  int32 major = 1;
+  int32 minor = 2;
+  int32 patch = 3;
 }
 
-
-message FactRequest {
-  Function function = 1;
-  string factName = 2;// Make it an enum when we know what kind of facts we would like to know about a function
+message PackageSource {
+  oneof source {
+    string r_mirror = 2;
+    string github_url = 3;
+  }
 }
 
-message Fact {
-  string factName = 2;
-  string factValue = 3;// Make it more typed when we know more about what kind of facts we want
+message Package {
+  string name = 1;
+  Version version = 2;
+  repeated bytes function_hashes = 4;
+  // What about package data? Maybe just the sysdata?
+  optional PackageSource source = 5;//If none, it is a base package or a local package
 }
+
+message PackageRequest {
+  bytes hash = 1;
+}
\ No newline at end of file
diff --git a/src/main/proto/routes.proto b/src/main/proto/routes.proto
index d3292e1fc..946e5094a 100644
--- a/src/main/proto/routes.proto
+++ b/src/main/proto/routes.proto
@@ -8,12 +8,12 @@ import "messages.proto";
 service CompileService {
   rpc Compile(CompileRequest) returns (CompileResponse) {}
   rpc Init(InitRequest) returns (InitResponse) {}
-  rpc LoadPackage(Package) returns (Empty) {}
 }
 
 // Used by the compile server to ask questions to R
 service FactService {
-  rpc GetFact(FactRequest) returns (Fact) {} // Generic fact
   rpc GetContext(ContextRequest) returns (Context) {}
   rpc GetTypeFeedback(FeedbackRequest) returns (TypeFeedback) {}
+  rpc GetValues(ValueRequest) returns (Values) {}
+  rpc GetFunction(FunctionRequest) returns (Function) {}
 }
\ No newline at end of file

From 4407ce32eb48f974a020347d9c8663d58b78d556 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 18 Jul 2024 18:17:17 +0200
Subject: [PATCH 12/80] Add tests for the InitRequest

---
 pom.xml                                       | 11 +++++
 .../java/org/prlprg/server/CompileServer.java | 28 +++++++++++-
 src/main/proto/messages.proto                 | 15 ++++---
 src/main/proto/routes.proto                   |  1 +
 .../java/org/prlprg/server/ServerTests.java   | 45 ++++++++++++++++++-
 5 files changed, 91 insertions(+), 9 deletions(-)

diff --git a/pom.xml b/pom.xml
index 9dc359bad..3502ed246 100644
--- a/pom.xml
+++ b/pom.xml
@@ -65,6 +65,17 @@
       <artifactId>grpc-services</artifactId>
       <version>${grpc.version}</version>
     </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-inprocess</artifactId>
+      <version>${grpc.version}</version>
+    </dependency>
+    <!-- To write unit tests for gRPC when using JUnit 5 -->
+    <dependency>
+      <groupId>com.asarkar.grpc</groupId>
+      <artifactId>grpc-test</artifactId>
+      <version>1.2.2</version>
+    </dependency>
     <dependency>
       <!-- necessary for Java 9+ -->
       <groupId>org.apache.tomcat</groupId>
diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index 3de04c1d6..70801bea0 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -1,5 +1,6 @@
 package org.prlprg.server;
 
+import com.google.protobuf.ByteString;
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
 import io.grpc.Status;
@@ -8,9 +9,11 @@
 import io.grpc.protobuf.services.ProtoReflectionService;
 import io.grpc.stub.StreamObserver;
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
+import org.prlprg.bc.Bc;
 import org.prlprg.bc.Compiler;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.session.GNURSession;
@@ -78,8 +81,14 @@ public static void main(String[] args) throws Exception {
     server.blockUntilShutdown();
   }
 
-  private static class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
+  static class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
     private @Nullable GNURSession session = null;
+    // Cache for all values (including functions)
+    private HashMap<ByteString, SEXP> cache = new HashMap<>();
+    // Cache for byte-code, only for functions
+    private HashMap<ByteString, Bc> bcCache = new HashMap<>();
+
+    // TODO: cache for native code, which should also include contexts
 
     // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
     // CompileService.Compile
@@ -122,6 +131,12 @@ public void compile(
               Status.INTERNAL.withDescription("Not a closure").asRuntimeException());
         }
       } else {
+        var functionHash = function.getHash();
+        Bc cached = bcCache.get(functionHash);
+        if (cached != null) {
+          // TODO:
+          // Serialize BcCode and COnstPool and set them in the response
+        }
         // We should cache the Compiler instance for that function and then
         // retrieve it here.
       }
@@ -143,9 +158,20 @@ public void init(
 
       var packages = request.getPackageHashList();
 
+      logger.info(
+          "Received init request with R version "
+              + RVersion
+              + "and Rsh version"
+              + rshVersion
+              + " and platform "
+              + platform);
+      logger.info("Received package hashes: " + packages);
+
       // Look into our cache if we have the packages.
       // Request the packages for those we do not have hashes for.
 
+      responseObserver.onNext(Messages.InitResponse.newBuilder().build());
+      responseObserver.onCompleted();
     }
   }
 }
diff --git a/src/main/proto/messages.proto b/src/main/proto/messages.proto
index 23ed0cfde..952a1348d 100644
--- a/src/main/proto/messages.proto
+++ b/src/main/proto/messages.proto
@@ -7,6 +7,11 @@ option java_package = "org.prlprg.server";
 // Status message: https://grpc.github.io/grpc-java/javadoc/io/grpc/Status.html
 
 // Init
+message Version {
+  int32 major = 1;
+  int32 minor = 2;
+  int32 patch = 3;
+}
 
 message InitRequest {
   Version Rsh_version = 1;// version of the compile server
@@ -31,7 +36,7 @@ message CompileRequest {
 message CompileResponse {
   bytes hash = 1;
   Tier tier = 2;
-  optional bytes native_code = 3;
+  optional bytes code = 3;
   optional bytes constant_pool = 4;
 }
 
@@ -39,7 +44,8 @@ message CompileResponse {
 message Function {
   bytes package_hash = 1;
   string name = 2; //What if it is a closure passed to a HOF?
-  optional bytes body = 3;
+  bytes hash = 3;
+  optional bytes body = 4;
   // what about the function parameters?
 }
 
@@ -146,11 +152,6 @@ message FeedbackRequest {
 
 // Packages
 
-message Version {
-  int32 major = 1;
-  int32 minor = 2;
-  int32 patch = 3;
-}
 
 message PackageSource {
   oneof source {
diff --git a/src/main/proto/routes.proto b/src/main/proto/routes.proto
index 946e5094a..ac6775360 100644
--- a/src/main/proto/routes.proto
+++ b/src/main/proto/routes.proto
@@ -11,6 +11,7 @@ service CompileService {
 }
 
 // Used by the compile server to ask questions to R
+// The server part there should be in the C++ code
 service FactService {
   rpc GetContext(ContextRequest) returns (Context) {}
   rpc GetTypeFeedback(FeedbackRequest) returns (TypeFeedback) {}
diff --git a/src/test/java/org/prlprg/server/ServerTests.java b/src/test/java/org/prlprg/server/ServerTests.java
index ff66ec7de..c3e72e261 100644
--- a/src/test/java/org/prlprg/server/ServerTests.java
+++ b/src/test/java/org/prlprg/server/ServerTests.java
@@ -1,3 +1,46 @@
 package org.prlprg.server;
 
-public class ServerTests {}
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+import com.asarkar.grpc.test.GrpcCleanupExtension;
+import com.asarkar.grpc.test.Resources;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import java.time.Duration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@ExtendWith(GrpcCleanupExtension.class)
+public class ServerTests {
+  @Test
+  void testCompile(Resources resources) {
+    // TODO
+  }
+
+  @Test
+  void testInit(Resources resources) throws Exception {
+    String serverName = InProcessServerBuilder.generateName();
+    var server =
+        InProcessServerBuilder.forName(serverName)
+            .directExecutor()
+            .addService(new CompileServer.CompileService())
+            .build()
+            .start();
+    resources.register(server, Duration.ofSeconds(3));
+    var channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+    resources.register(channel, Duration.ofSeconds(3));
+    CompileServiceGrpc.CompileServiceBlockingStub blockingStub =
+        CompileServiceGrpc.newBlockingStub(channel);
+
+    var initRequest =
+        Messages.InitRequest.newBuilder()
+            .setRVersion(Messages.Version.newBuilder().setMajor(4).setMinor(3).setPatch(2).build())
+            .setRshVersion(Messages.Version.newBuilder().build())
+            .setPlatform("amd64")
+            .build();
+    assertDoesNotThrow(
+        () -> {
+          Messages.InitResponse response = blockingStub.init(initRequest);
+        });
+  }
+}

From a4f623434ddd0b5b522aadd147fa5a5c61cd726a Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 18 Jul 2024 18:43:27 +0200
Subject: [PATCH 13/80] WIP on compile request

---
 src/main/java/org/prlprg/server/CompileServer.java | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index 70801bea0..37a49ad40 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -135,9 +135,13 @@ public void compile(
         Bc cached = bcCache.get(functionHash);
         if (cached != null) {
           // TODO:
-          // Serialize BcCode and COnstPool and set them in the response
+          // Serialize BcCode and ConstPool and set them in the response
+        } else {
+          // Compile the function
+
+          // Add it to the code cache
         }
-        // We should cache the Compiler instance for that function and then
+        // TODO: We should cache the Compiler instance for that function and then
         // retrieve it here.
       }
 

From dba6aaf54695c7de7f2e1c8b0b26444289b424db Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 19 Jul 2024 13:47:16 +0200
Subject: [PATCH 14/80] Test the compile request

---
 src/main/java/org/prlprg/rds/RDSWriter.java   |   7 +
 .../java/org/prlprg/server/CompileServer.java | 110 --------------
 .../org/prlprg/server/CompileService.java     | 137 ++++++++++++++++++
 .../java/org/prlprg/server/ServerTests.java   |  78 ++++++++--
 4 files changed, 210 insertions(+), 122 deletions(-)
 create mode 100644 src/main/java/org/prlprg/server/CompileService.java

diff --git a/src/main/java/org/prlprg/rds/RDSWriter.java b/src/main/java/org/prlprg/rds/RDSWriter.java
index 17808eff7..5b1903b06 100644
--- a/src/main/java/org/prlprg/rds/RDSWriter.java
+++ b/src/main/java/org/prlprg/rds/RDSWriter.java
@@ -1,5 +1,6 @@
 package org.prlprg.rds;
 
+import com.google.protobuf.ByteString;
 import java.io.*;
 import java.nio.charset.Charset;
 import java.util.*;
@@ -34,6 +35,12 @@ public static void writeStream(OutputStream output, SEXP sexp) throws IOExceptio
     }
   }
 
+  public static ByteString writeByteString(SEXP sexp) throws IOException {
+    var output = ByteString.newOutput();
+    RDSWriter.writeStream(output, sexp);
+    return output.toByteString();
+  }
+
   /**
    * Writes a SEXP to the provided file.
    *
diff --git a/src/main/java/org/prlprg/server/CompileServer.java b/src/main/java/org/prlprg/server/CompileServer.java
index 37a49ad40..830ada6ef 100644
--- a/src/main/java/org/prlprg/server/CompileServer.java
+++ b/src/main/java/org/prlprg/server/CompileServer.java
@@ -1,24 +1,12 @@
 package org.prlprg.server;
 
-import com.google.protobuf.ByteString;
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
-import io.grpc.Status;
 import io.grpc.health.v1.HealthCheckResponse;
 import io.grpc.protobuf.services.HealthStatusManager;
 import io.grpc.protobuf.services.ProtoReflectionService;
-import io.grpc.stub.StreamObserver;
-import java.io.IOException;
-import java.util.HashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
-import javax.annotation.Nullable;
-import org.prlprg.bc.Bc;
-import org.prlprg.bc.Compiler;
-import org.prlprg.rds.RDSReader;
-import org.prlprg.session.GNURSession;
-import org.prlprg.sexp.CloSXP;
-import org.prlprg.sexp.SEXP;
 
 class CompileServer {
   private static final Logger logger = Logger.getLogger(CompileServer.class.getName());
@@ -80,102 +68,4 @@ public static void main(String[] args) throws Exception {
     server.start();
     server.blockUntilShutdown();
   }
-
-  static class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
-    private @Nullable GNURSession session = null;
-    // Cache for all values (including functions)
-    private HashMap<ByteString, SEXP> cache = new HashMap<>();
-    // Cache for byte-code, only for functions
-    private HashMap<ByteString, Bc> bcCache = new HashMap<>();
-
-    // TODO: cache for native code, which should also include contexts
-
-    // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
-    // CompileService.Compile
-    @Override
-    public void compile(
-        Messages.CompileRequest request,
-        StreamObserver<Messages.CompileResponse> responseObserver) {
-
-      if (session == null) {
-        responseObserver.onError(
-            Status.INTERNAL.withDescription("Session not initialized.").asRuntimeException());
-      }
-
-      // Parse the request
-      Messages.Function function = request.getFunction();
-      Messages.Tier tier = request.getTier(); // Default is baseline
-      int optimizationLevel = request.getOptimizationLevel(); // default is 0
-      Messages.Context context = request.getContext(); // null if not provided
-
-      logger.info("Received request to compile function " + function.getName());
-
-      // Compile the code and build response
-      Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
-      // TODO
-      if (function.hasBody()) {
-        SEXP closure = null;
-        try {
-          closure = RDSReader.readByteString(session, function.getBody());
-        } catch (IOException e) {
-          throw new RuntimeException(e);
-        }
-        if (closure instanceof CloSXP c) {
-          Compiler compiler = new Compiler(c, session);
-        } else {
-          // See
-          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
-          // We could have more details using that:
-          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
-          responseObserver.onError(
-              Status.INTERNAL.withDescription("Not a closure").asRuntimeException());
-        }
-      } else {
-        var functionHash = function.getHash();
-        Bc cached = bcCache.get(functionHash);
-        if (cached != null) {
-          // TODO:
-          // Serialize BcCode and ConstPool and set them in the response
-        } else {
-          // Compile the function
-
-          // Add it to the code cache
-        }
-        // TODO: We should cache the Compiler instance for that function and then
-        // retrieve it here.
-      }
-
-      // Send the response
-      response.setTier(tier);
-      responseObserver.onNext(response.build());
-      responseObserver.onCompleted();
-    }
-
-    @Override
-    public void init(
-        Messages.InitRequest request, StreamObserver<Messages.InitResponse> responseObserver) {
-
-      // Parse the request
-      Messages.Version rshVersion = request.getRshVersion();
-      Messages.Version RVersion = request.getRVersion();
-      String platform = request.getPlatform();
-
-      var packages = request.getPackageHashList();
-
-      logger.info(
-          "Received init request with R version "
-              + RVersion
-              + "and Rsh version"
-              + rshVersion
-              + " and platform "
-              + platform);
-      logger.info("Received package hashes: " + packages);
-
-      // Look into our cache if we have the packages.
-      // Request the packages for those we do not have hashes for.
-
-      responseObserver.onNext(Messages.InitResponse.newBuilder().build());
-      responseObserver.onCompleted();
-    }
-  }
 }
diff --git a/src/main/java/org/prlprg/server/CompileService.java b/src/main/java/org/prlprg/server/CompileService.java
new file mode 100644
index 000000000..069ccddb4
--- /dev/null
+++ b/src/main/java/org/prlprg/server/CompileService.java
@@ -0,0 +1,137 @@
+package org.prlprg.server;
+
+import com.google.protobuf.ByteString;
+import io.grpc.Status;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import org.prlprg.bc.Bc;
+import org.prlprg.bc.Compiler;
+import org.prlprg.rds.RDSReader;
+import org.prlprg.rds.RDSWriter;
+import org.prlprg.session.GNURSession;
+import org.prlprg.sexp.BCodeSXP;
+import org.prlprg.sexp.CloSXP;
+import org.prlprg.sexp.SEXP;
+import org.prlprg.sexp.SEXPs;
+
+class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
+  private static final Logger logger = Logger.getLogger(CompileServer.class.getName());
+
+  private @Nullable GNURSession session = null;
+  // Cache for all values (including functions)
+  private HashMap<ByteString, SEXP> cache = new HashMap<>();
+  // Cache for byte-code, only for functions
+  private HashMap<ByteString, Bc> bcCache = new HashMap<>();
+
+  // TODO: cache for native code, which should also include contexts
+
+  // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
+  // CompileService.Compile
+  @Override
+  public void compile(
+      Messages.CompileRequest request, StreamObserver<Messages.CompileResponse> responseObserver) {
+
+    if (session == null) {
+      responseObserver.onError(
+          Status.INTERNAL.withDescription("Session not initialized.").asRuntimeException());
+    }
+
+    // Parse the request
+    Messages.Function function = request.getFunction();
+    Messages.Tier tier = request.getTier(); // Default is baseline
+    int optimizationLevel = request.getOptimizationLevel(); // default is 0
+    Messages.Context context = request.getContext(); // null if not provided
+
+    logger.info("Received request to compile function " + function.getName());
+
+    // Compile the code and build response
+    Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
+    // TODO
+    if (function.hasBody()) {
+      SEXP closure = null;
+      try {
+        closure = RDSReader.readByteString(session, function.getBody());
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      if (closure instanceof CloSXP c) {
+        Compiler compiler = new Compiler(c, session);
+        compiler.setOptimizationLevel(optimizationLevel);
+        var res = compiler.compile();
+        if (res.isEmpty()) {
+          responseObserver.onError(
+              Status.INTERNAL
+                  .withDescription("Cannot compile with browser() in the function")
+                  .asRuntimeException());
+        } else {
+          BCodeSXP bc = SEXPs.bcode(res.get());
+          ByteString serializedBc = null;
+          try {
+            serializedBc = RDSWriter.writeByteString(bc);
+          } catch (Exception e) {
+            responseObserver.onError(
+                Status.INTERNAL
+                    .withDescription("Impossible to serialize the bytecode")
+                    .asRuntimeException());
+          }
+          assert serializedBc != null;
+          response.setCode(serializedBc);
+        }
+      } else {
+        // See
+        // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+        // We could have more details using that:
+        // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
+        responseObserver.onError(
+            Status.INTERNAL.withDescription("Not a closure").asRuntimeException());
+      }
+    } else {
+      var functionHash = function.getHash();
+      Bc cached = bcCache.get(functionHash);
+      // Also cache the optimization level?
+      if (cached != null) {
+        // TODO:
+        // Serialize BcCode and ConstPool and set them in the response
+      } else {
+        // Compile the function
+
+        // Add it to the code cache
+      }
+    }
+
+    // Send the response
+    response.setTier(tier);
+    responseObserver.onNext(response.build());
+    responseObserver.onCompleted();
+  }
+
+  @Override
+  public void init(
+      Messages.InitRequest request, StreamObserver<Messages.InitResponse> responseObserver) {
+
+    // Parse the request
+    Messages.Version rshVersion = request.getRshVersion();
+    Messages.Version RVersion = request.getRVersion();
+    String platform = request.getPlatform();
+
+    var packages = request.getPackageHashList();
+
+    logger.info(
+        "Received init request with R version "
+            + RVersion
+            + "and Rsh version"
+            + rshVersion
+            + " and platform "
+            + platform);
+    logger.info("Received package hashes: " + packages);
+
+    // Look into our cache if we have the packages.
+    // Request the packages for those we do not have hashes for.
+
+    responseObserver.onNext(Messages.InitResponse.newBuilder().build());
+    responseObserver.onCompleted();
+  }
+}
diff --git a/src/test/java/org/prlprg/server/ServerTests.java b/src/test/java/org/prlprg/server/ServerTests.java
index c3e72e261..1d0854239 100644
--- a/src/test/java/org/prlprg/server/ServerTests.java
+++ b/src/test/java/org/prlprg/server/ServerTests.java
@@ -1,36 +1,89 @@
 package org.prlprg.server;
 
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.*;
 
 import com.asarkar.grpc.test.GrpcCleanupExtension;
 import com.asarkar.grpc.test.Resources;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
+import java.io.IOException;
 import java.time.Duration;
+import javax.annotation.Nullable;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.prlprg.rds.RDSWriter;
+import org.prlprg.sexp.SEXPs;
+import org.prlprg.sexp.TaggedElem;
 
 @ExtendWith(GrpcCleanupExtension.class)
 public class ServerTests {
-  @Test
-  void testCompile(Resources resources) {
-    // TODO
-  }
 
-  @Test
-  void testInit(Resources resources) throws Exception {
+  private @Nullable Server server;
+  private @Nullable ManagedChannel channel;
+  private @Nullable CompileServiceGrpc.CompileServiceBlockingStub blockingStub;
+
+  @BeforeEach
+  public void setupServer() throws IOException {
     String serverName = InProcessServerBuilder.generateName();
-    var server =
+    server =
         InProcessServerBuilder.forName(serverName)
             .directExecutor()
-            .addService(new CompileServer.CompileService())
+            .addService(new CompileService())
             .build()
             .start();
+
+    channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+    blockingStub = CompileServiceGrpc.newBlockingStub(channel);
+  }
+
+  @AfterEach
+  public void tearDown() {
+    assert server != null;
+    server.shutdown();
+  }
+
+  @Test
+  void testCompile(Resources resources) throws IOException {
+    assert server != null;
+    resources.register(server, Duration.ofSeconds(3));
+    assert channel != null;
+    resources.register(channel, Duration.ofSeconds(3));
+
+    var function =
+        SEXPs.closure(
+            SEXPs.list(new TaggedElem("x", SEXPs.symbol("x"))), SEXPs.symbol("x"), SEXPs.EMPTY_ENV);
+    var f =
+        Messages.Function.newBuilder()
+            .setName("testFunc")
+            .setBody(RDSWriter.writeByteString(function))
+            .build();
+    var compileRequest =
+        Messages.CompileRequest.newBuilder()
+            .setFunction(f)
+            .setTier(Messages.Tier.BASELINE)
+            .setOptimizationLevel(0)
+            .setContext(Messages.Context.newBuilder().build())
+            .build();
+
+    final Messages.CompileResponse[] response = new Messages.CompileResponse[1];
+    assertDoesNotThrow(
+        () -> {
+          assert blockingStub != null;
+          response[0] = blockingStub.compile(compileRequest);
+        });
+    assertNotNull(response[0].getCode());
+  }
+
+  @Test
+  void testInit(Resources resources) throws Exception {
+    assert server != null;
     resources.register(server, Duration.ofSeconds(3));
-    var channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+    assert channel != null;
     resources.register(channel, Duration.ofSeconds(3));
-    CompileServiceGrpc.CompileServiceBlockingStub blockingStub =
-        CompileServiceGrpc.newBlockingStub(channel);
 
     var initRequest =
         Messages.InitRequest.newBuilder()
@@ -40,6 +93,7 @@ void testInit(Resources resources) throws Exception {
             .build();
     assertDoesNotThrow(
         () -> {
+          assert blockingStub != null;
           Messages.InitResponse response = blockingStub.init(initRequest);
         });
   }

From 33b7f78adc217e1fcc364038a0ef9d90fd9f03e7 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 19 Jul 2024 17:11:00 +0200
Subject: [PATCH 15/80] Read a package database (rdx and rdb)

---
 src/main/java/org/prlprg/RVersion.java        |  2 +-
 .../org/prlprg/server/CompileService.java     | 81 ++++++++++++-------
 .../java/org/prlprg/session/GNURSession.java  | 50 +++++++++++-
 src/test/java/org/prlprg/TestConfig.java      |  2 +-
 4 files changed, 102 insertions(+), 33 deletions(-)

diff --git a/src/main/java/org/prlprg/RVersion.java b/src/main/java/org/prlprg/RVersion.java
index c307ef3b8..82b96d918 100644
--- a/src/main/java/org/prlprg/RVersion.java
+++ b/src/main/java/org/prlprg/RVersion.java
@@ -46,7 +46,7 @@ public static RVersion parse(String textual) {
     return new RVersion(major, minor, patch, suffix);
   }
 
-  RVersion(int major, int minor, int patch) {
+  public RVersion(int major, int minor, int patch) {
     this(major, minor, patch, null);
   }
 
diff --git a/src/main/java/org/prlprg/server/CompileService.java b/src/main/java/org/prlprg/server/CompileService.java
index 069ccddb4..9d2fdeb16 100644
--- a/src/main/java/org/prlprg/server/CompileService.java
+++ b/src/main/java/org/prlprg/server/CompileService.java
@@ -7,6 +7,7 @@
 import java.util.HashMap;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
+import org.prlprg.RVersion;
 import org.prlprg.bc.Bc;
 import org.prlprg.bc.Compiler;
 import org.prlprg.rds.RDSReader;
@@ -51,42 +52,20 @@ public void compile(
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
     // TODO
     if (function.hasBody()) {
-      SEXP closure = null;
       try {
-        closure = RDSReader.readByteString(session, function.getBody());
-      } catch (IOException e) {
-        throw new RuntimeException(e);
-      }
-      if (closure instanceof CloSXP c) {
-        Compiler compiler = new Compiler(c, session);
-        compiler.setOptimizationLevel(optimizationLevel);
-        var res = compiler.compile();
-        if (res.isEmpty()) {
-          responseObserver.onError(
-              Status.INTERNAL
-                  .withDescription("Cannot compile with browser() in the function")
-                  .asRuntimeException());
-        } else {
-          BCodeSXP bc = SEXPs.bcode(res.get());
-          ByteString serializedBc = null;
-          try {
-            serializedBc = RDSWriter.writeByteString(bc);
-          } catch (Exception e) {
-            responseObserver.onError(
-                Status.INTERNAL
-                    .withDescription("Impossible to serialize the bytecode")
-                    .asRuntimeException());
-          }
-          assert serializedBc != null;
-          response.setCode(serializedBc);
-        }
-      } else {
+        ByteString serializedBc =
+            compileClosure(function.getBody(), optimizationLevel, responseObserver);
+        response.setCode(serializedBc);
+      } catch (Exception e) {
         // See
         // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
         // We could have more details using that:
         // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
         responseObserver.onError(
-            Status.INTERNAL.withDescription("Not a closure").asRuntimeException());
+            Status.INTERNAL
+                .withDescription(
+                    "Cannot compile function " + function.getName() + " ; " + e.getMessage())
+                .asRuntimeException());
       }
     } else {
       var functionHash = function.getHash();
@@ -96,6 +75,8 @@ public void compile(
         // TODO:
         // Serialize BcCode and ConstPool and set them in the response
       } else {
+        // Ask the client for the body of the function
+
         // Compile the function
 
         // Add it to the code cache
@@ -128,10 +109,50 @@ public void init(
             + platform);
     logger.info("Received package hashes: " + packages);
 
+    // TODO: Lookup to see if we have this version of R installed or not.
+    session = new GNURSession(convertVersion(RVersion), null);
+
     // Look into our cache if we have the packages.
     // Request the packages for those we do not have hashes for.
 
     responseObserver.onNext(Messages.InitResponse.newBuilder().build());
     responseObserver.onCompleted();
   }
+
+  private RVersion convertVersion(Messages.Version version) {
+    return new RVersion(version.getMajor(), version.getMinor(), version.getPatch());
+  }
+
+  private ByteString compileClosure(
+      ByteString body,
+      int optimizationLevel,
+      StreamObserver<Messages.CompileResponse> responseObserver) {
+    SEXP closure = null;
+    ByteString serializedBc = null;
+    try {
+      assert session != null;
+      closure = RDSReader.readByteString(session, body);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+    if (closure instanceof CloSXP c) {
+      Compiler compiler = new Compiler(c, session);
+      compiler.setOptimizationLevel(optimizationLevel);
+      var res = compiler.compile();
+      if (res.isEmpty()) {
+        throw new RuntimeException("Cannot compile a closure with a browser call");
+      } else {
+        BCodeSXP bc = SEXPs.bcode(res.get());
+
+        try {
+          serializedBc = RDSWriter.writeByteString(bc);
+        } catch (Exception e) {
+          throw new RuntimeException("Impossible to serialize the bytecode");
+        }
+      }
+    } else {
+      throw new RuntimeException("Not a closure");
+    }
+    return serializedBc;
+  }
 }
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index 35f9daf2a..4633dbd5b 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -1,5 +1,6 @@
 package org.prlprg.session;
 
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.net.URI;
 import java.nio.file.Path;
@@ -45,7 +46,44 @@ public void loadPackage(String name, String version) {
     // Or rather do lazy loading like R?
   }
 
-  private void readPackageDatabase(Path path, String packageName) {}
+  private HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName)
+      throws IOException {
+    // .libPaths and installed_packages() in R can help to see
+    // where packages are installed
+    var basePath = path.resolve("R");
+    // Read the index file .rdx
+    // we get a list with 3 elements, variables, references and compressed
+    // See LazyLoading in https://cran.r-project.org/doc/manuals/r-devel/R-ints.html
+    var index = RDSReader.readFile(this, basePath.resolve(packageName + ".rdx").toFile());
+
+    // Load objects .rdb
+    var objectFile = basePath.resolve(packageName + ".rdb").toFile();
+    try (var input = new FileInputStream(objectFile)) {
+
+      if (index instanceof ListSXP l) {
+        var variables = (ListSXP) l.get(0).value();
+        var references = (ListSXP) l.get(1).value();
+        // We ignore compressed. Nowadays, it is always compressed
+
+        var bindings = new HashMap<String, CloSXP>(variables.size());
+
+        int offset = 0;
+        for (int i = 0; i < variables.size(); i++) {
+          var name = variables.get(i).tag();
+          var posInRdb = (IntSXP) variables.get(i).value();
+
+          input.skip(posInRdb.get(0) - offset);
+          offset = posInRdb.get(0);
+          // Read the object from the rdb file at the right positions
+          var obj = RDSReader.readStream(this, input);
+          bindings.put(name, (CloSXP) obj);
+        }
+        return bindings;
+      } else {
+        throw new RuntimeException("Invalid index file");
+      }
+    }
+  }
 
   /**
    * Makes it possible to load a package by providing its functions directly.
@@ -79,6 +117,16 @@ public EnvSXP loadPackage(String name, String version, List<Messages.Function> f
     return new NamespaceEnvSXP(name, version, baseNamespace, bindings);
   }
 
+  /**
+   * Load the base environment and namespace.
+   *
+   * <p>It requires a special treatment as the reader refers to base functions and so we need to
+   * carefully load symbols and then bind them.
+   */
+  public void loadBase(List<Messages.Function> functions) {
+    // TODO
+  }
+
   @Override
   public NamespaceEnvSXP baseNamespace() {
     return null;
diff --git a/src/test/java/org/prlprg/TestConfig.java b/src/test/java/org/prlprg/TestConfig.java
index 8c14eb637..575c99472 100644
--- a/src/test/java/org/prlprg/TestConfig.java
+++ b/src/test/java/org/prlprg/TestConfig.java
@@ -26,7 +26,7 @@ public class TestConfig extends Config {
    *
    * <p>This is <b>unset</b> by default.
    */
-  public static final boolean FAST_TESTS = get("FAST_TESTS", false);
+  public static final boolean FAST_TESTS = get("FAST_TESTS", true);
 
   /**
    * Whether to enable additional logging.

From a1eef99e21736ddaf76e83c1c211bb650dde5608 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 19 Jul 2024 18:19:11 +0200
Subject: [PATCH 16/80] Testing the GNURSession

---
 .../java/org/prlprg/session/GNURSession.java  |  6 +++---
 .../org/prlprg/rsession/GNURSessionTest.java  | 20 +++++++++++++++++++
 2 files changed, 23 insertions(+), 3 deletions(-)
 create mode 100644 src/test/java/org/prlprg/rsession/GNURSessionTest.java

diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index 4633dbd5b..54ec3fe4d 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -26,7 +26,7 @@ public class GNURSession implements RSession {
   private @Nullable HashMap<String, NamespaceEnvSXP> namespaces = null;
 
   // TODO: need the path to R *and* the path to the installed packages
-  public GNURSession(org.prlprg.RVersion version, Path r_dir) {
+  public GNURSession(RVersion version, Path r_dir) {
     cranMirror = URI.create("https://cran.r-project.org");
     RVersion = version;
   }
@@ -46,11 +46,11 @@ public void loadPackage(String name, String version) {
     // Or rather do lazy loading like R?
   }
 
-  private HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName)
+  public HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName)
       throws IOException {
     // .libPaths and installed_packages() in R can help to see
     // where packages are installed
-    var basePath = path.resolve("R");
+    var basePath = path.resolve(packageName + "/R");
     // Read the index file .rdx
     // we get a list with 3 elements, variables, references and compressed
     // See LazyLoading in https://cran.r-project.org/doc/manuals/r-devel/R-ints.html
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
new file mode 100644
index 000000000..f6036cc03
--- /dev/null
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -0,0 +1,20 @@
+package org.prlprg.rsession;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.prlprg.RVersion;
+import org.prlprg.session.GNURSession;
+
+public class GNURSessionTest {
+  @Test
+  public void testReadPackageDatabase() throws IOException {
+    var session = new GNURSession(RVersion.LATEST_AWARE, null);
+    var p = "/home/pierre/R/x86_64-pc-linux-gnu-library/4.3/";
+    p = p.replaceFirst("^~", System.getProperty("user.home"));
+    var funs = session.readPackageDatabase(Path.of(p), "askpass");
+
+    Assertions.assertFalse(funs.isEmpty());
+  }
+}

From d683438feebebf74ed91dbada8bd7f62b0797f1d Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 22 Jul 2024 17:07:28 +0200
Subject: [PATCH 17/80] Read rdb files.

Note that the objects are Zlib encoded, not GZIP encoded!
---
 src/main/java/org/prlprg/rds/RDSReader.java   | 24 +++++++++----
 .../java/org/prlprg/session/GNURSession.java  | 35 ++++++++++++++-----
 .../org/prlprg/rsession/GNURSessionTest.java  |  2 +-
 3 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index ca1d3123d..055dd8538 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -12,6 +12,7 @@
 import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.*;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import org.prlprg.bc.Bc;
 import org.prlprg.primitive.Complex;
@@ -47,12 +48,13 @@ public class RDSReader implements Closeable {
   private final RSession rsession;
   private final RDSInputStream in;
   private final List<SEXP> refTable = new ArrayList<>(128);
+  private final Logger logger = Logger.getLogger(RDSReader.class.getName());
 
   // FIXME: this should include the logic from platform.c
   //  or should we individually read the charset property of each SEXP? this will require
   //  verifying which SEXPs we need to write the charset for--just CHARSXP, or also
   //  builtin/special?
-  private final Charset nativeEncoding = Charset.defaultCharset();
+  private Charset nativeEncoding = Charset.defaultCharset();
 
   private RDSReader(RSession session, InputStream in) {
     this.rsession = session;
@@ -90,22 +92,30 @@ public static SEXP readByteString(RSession session, ByteString byteString) throw
   }
 
   private void readHeader() throws IOException {
-
-    if (in.readByte() != 'X') {
-      throw new RDSException("Unsupported type (possibly compressed)");
+    var RDSkind = in.readByte();
+    if (RDSkind != 'X') {
+      throw new RDSException("Unsupported type (possibly compressed): " + RDSkind);
     }
     assert in.readByte() == '\n';
 
     // versions
     var formatVersion = in.readInt();
-    if (formatVersion != 2) {
-      // we do not support RDS version 3 because it uses ALTREP
-      throw new RDSException("Unsupported RDS version: " + formatVersion);
+    if (formatVersion > 2) {
+      // we do not completely support RDS version 3 because it uses ALTREP
+      logger.warning("RDS version: " + formatVersion + "; some features are not supported.");
     }
     // writer version
     in.readInt();
     // minimal reader version
     in.readInt();
+
+    if (formatVersion >= 3) {
+      int encodingLength = in.readInt();
+      if (encodingLength > 0) {
+        var encoding = in.readString(encodingLength, nativeEncoding);
+        nativeEncoding = Charset.forName(encoding);
+      }
+    }
   }
 
   public SEXP read() throws IOException {
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index 54ec3fe4d..691490ad0 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -7,6 +7,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.zip.InflaterInputStream;
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
 import org.prlprg.rds.RDSReader;
@@ -60,23 +61,41 @@ public HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName
     var objectFile = basePath.resolve(packageName + ".rdb").toFile();
     try (var input = new FileInputStream(objectFile)) {
 
-      if (index instanceof ListSXP l) {
-        var variables = (ListSXP) l.get(0).value();
-        var references = (ListSXP) l.get(1).value();
-        // We ignore compressed. Nowadays, it is always compressed
+      if (index instanceof VecSXP l) {
+        var variables = (VecSXP) l.get(0);
+        var names = variables.names();
+        var references = (VecSXP) l.get(1);
+        // Nowadays, it is always compressed. It can be a boolean,
+        // or an Int to indicate the compression algorithm: 2 bzip2, 3: xz
+        var compressed = l.get(2);
+        if (compressed instanceof IntSXP i) {
+          var algo =
+              switch (i.get(0)) {
+                case 2 -> "bzip2";
+                case 3 -> "xz";
+                default -> "unknown";
+              };
+          // For the other ones, there would be one more byte in addition to the length
+          // that would contain the compression method again or 0 if the compressed size
+          // had exceeded the uncompressed one.
+          throw new RuntimeException(algo + " compression detected; only gzip is supported");
+        }
 
         var bindings = new HashMap<String, CloSXP>(variables.size());
 
         int offset = 0;
         for (int i = 0; i < variables.size(); i++) {
-          var name = variables.get(i).tag();
-          var posInRdb = (IntSXP) variables.get(i).value();
+          var posInRdb = (IntSXP) variables.get(i);
 
           input.skip(posInRdb.get(0) - offset);
           offset = posInRdb.get(0);
+          byte[] len = input.readNBytes(4); // Skip the 4 bytes of the length
+          // convert to a 4 byte big endian int
+          int length = (len[0] << 24) | (len[1] << 16) | (len[2] << 8) | len[3];
           // Read the object from the rdb file at the right positions
-          var obj = RDSReader.readStream(this, input);
-          bindings.put(name, (CloSXP) obj);
+          assert length + 4 == posInRdb.get(1) + 1;
+          var obj = RDSReader.readStream(this, new InflaterInputStream(input));
+          bindings.put(names.get(i), (CloSXP) obj);
         }
         return bindings;
       } else {
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index f6036cc03..adce46aa9 100644
--- a/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -11,7 +11,7 @@ public class GNURSessionTest {
   @Test
   public void testReadPackageDatabase() throws IOException {
     var session = new GNURSession(RVersion.LATEST_AWARE, null);
-    var p = "/home/pierre/R/x86_64-pc-linux-gnu-library/4.3/";
+    var p = "~/R/x86_64-pc-linux-gnu-library/4.3/";
     p = p.replaceFirst("^~", System.getProperty("user.home"));
     var funs = session.readPackageDatabase(Path.of(p), "askpass");
 

From 69b576f4e6957f6b875af0e35ba43c2d8aa7c6a3 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 22 Jul 2024 18:10:10 +0200
Subject: [PATCH 18/80] Adding a persistent hook for reading environments

---
 src/main/java/org/prlprg/rds/RDSReader.java   | 30 ++++++++++++++-
 .../java/org/prlprg/session/GNURSession.java  | 38 +++++++++++++++++--
 .../org/prlprg/rsession/GNURSessionTest.java  |  2 +-
 3 files changed, 64 insertions(+), 6 deletions(-)

diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index 055dd8538..6a0e7f3b1 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -50,6 +50,14 @@ public class RDSReader implements Closeable {
   private final List<SEXP> refTable = new ArrayList<>(128);
   private final Logger logger = Logger.getLogger(RDSReader.class.getName());
 
+  // User-provided hook for PERSISTSXP
+  // Used for package databases for instance
+  public interface Hook {
+    SEXP hook(SEXP sexp);
+  }
+
+  private Hook hook = null;
+
   // FIXME: this should include the logic from platform.c
   //  or should we individually read the charset property of each SEXP? this will require
   //  verifying which SEXPs we need to write the charset for--just CHARSXP, or also
@@ -61,6 +69,10 @@ private RDSReader(RSession session, InputStream in) {
     this.in = new RDSInputStream(in);
   }
 
+  private void setHook(Hook hook) {
+    this.hook = hook;
+  }
+
   /**
    * Reads a SEXP from the provided file.
    *
@@ -87,6 +99,13 @@ public static SEXP readStream(RSession session, InputStream input) throws IOExce
     }
   }
 
+  public static SEXP readStream(RSession session, InputStream input, Hook hook) throws IOException {
+    try (var reader = new RDSReader(session, input)) {
+      reader.setHook(hook);
+      return reader.read();
+    }
+  }
+
   public static SEXP readByteString(RSession session, ByteString byteString) throws IOException {
     return RDSReader.readStream(session, byteString.newInput());
   }
@@ -166,12 +185,21 @@ private SEXP readItem() throws IOException {
                 throw new RDSException("Unexpected bytecode reference here (not in bytecode)");
             case ATTRLANGSXP, ATTRLISTSXP -> throw new RDSException("Unexpected attr here");
             case UNBOUNDVALUE_SXP -> SEXPs.UNBOUND_VALUE;
-            case GENERICREFSXP, PACKAGESXP, PERSISTSXP, CLASSREFSXP, ALTREPSXP ->
+            case PERSISTSXP -> readPersist(flags);
+            case GENERICREFSXP, PACKAGESXP, CLASSREFSXP, ALTREPSXP ->
                 throw new RDSException("Unsupported RDS special type: " + s);
           };
     };
   }
 
+  private SEXP readPersist(Flags flags) throws IOException {
+    var strs = readStringVec();
+    // Call the persistent hook on that strsxp
+    var res = hook.hook(strs);
+    refTable.add(res);
+    return res;
+  }
+
   private SEXP readComplex(Flags flags) throws IOException {
     var length = in.readInt();
     var cplx = ImmutableList.<Complex>builder();
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index 691490ad0..a9154e9e8 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -2,6 +2,7 @@
 
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.URI;
 import java.nio.file.Path;
 import java.util.HashMap;
@@ -47,7 +48,36 @@ public void loadPackage(String name, String version) {
     // Or rather do lazy loading like R?
   }
 
-  public HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName)
+  class EnvHook implements RDSReader.Hook {
+    private HashMap<String, VecSXP> references = new HashMap<>();
+    private InputStream in;
+
+    EnvHook(VecSXP refs, InputStream in) {
+      this.in = in;
+      var names = refs.names();
+      for (int i = 0; i < refs.size(); i++) {
+        this.references.put(names.get(i), (VecSXP) refs.get(i));
+      }
+    }
+
+    @Override
+    public SEXP hook(SEXP sexp) {
+      if (sexp instanceof StrSXP s) {
+        var position = references.getOrDefault(s.get(0), (VecSXP) sexp);
+
+        // TODO: factorize with the other object reading function
+        // And it looks like we cannot read linearly, can't we?
+        // or we need first to merge the symbols and the temp environments in offset increasing
+        // order
+        // and then load in order.
+        return sexp;
+      }
+
+      return sexp;
+    }
+  }
+
+  public HashMap<String, SEXP> readPackageDatabase(Path path, String packageName)
       throws IOException {
     // .libPaths and installed_packages() in R can help to see
     // where packages are installed
@@ -78,10 +108,10 @@ public HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName
           // For the other ones, there would be one more byte in addition to the length
           // that would contain the compression method again or 0 if the compressed size
           // had exceeded the uncompressed one.
-          throw new RuntimeException(algo + " compression detected; only gzip is supported");
+          throw new RuntimeException(algo + " compression detected; only zlib is supported");
         }
 
-        var bindings = new HashMap<String, CloSXP>(variables.size());
+        var bindings = new HashMap<String, SEXP>(variables.size());
 
         int offset = 0;
         for (int i = 0; i < variables.size(); i++) {
@@ -95,7 +125,7 @@ public HashMap<String, CloSXP> readPackageDatabase(Path path, String packageName
           // Read the object from the rdb file at the right positions
           assert length + 4 == posInRdb.get(1) + 1;
           var obj = RDSReader.readStream(this, new InflaterInputStream(input));
-          bindings.put(names.get(i), (CloSXP) obj);
+          bindings.put(names.get(i), obj);
         }
         return bindings;
       } else {
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index adce46aa9..76905781c 100644
--- a/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -13,7 +13,7 @@ public void testReadPackageDatabase() throws IOException {
     var session = new GNURSession(RVersion.LATEST_AWARE, null);
     var p = "~/R/x86_64-pc-linux-gnu-library/4.3/";
     p = p.replaceFirst("^~", System.getProperty("user.home"));
-    var funs = session.readPackageDatabase(Path.of(p), "askpass");
+    var funs = session.readPackageDatabase(Path.of(p), "yaml");
 
     Assertions.assertFalse(funs.isEmpty());
   }

From 0d598ea36f135a0d64e9cd0b6af977fa81a152ee Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 23 Jul 2024 17:33:39 +0200
Subject: [PATCH 19/80] Correct env hook + refactor

---
 src/main/java/org/prlprg/rds/RDSReader.java   |   5 +-
 .../java/org/prlprg/session/GNURSession.java  |  66 +-------
 .../org/prlprg/session/PackageDatabase.java   | 160 ++++++++++++++++++
 3 files changed, 172 insertions(+), 59 deletions(-)
 create mode 100644 src/main/java/org/prlprg/session/PackageDatabase.java

diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index 6a0e7f3b1..cebe61123 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -53,7 +53,7 @@ public class RDSReader implements Closeable {
   // User-provided hook for PERSISTSXP
   // Used for package databases for instance
   public interface Hook {
-    SEXP hook(SEXP sexp);
+    SEXP hook(SEXP sexp) throws IOException;
   }
 
   private Hook hook = null;
@@ -195,6 +195,9 @@ private SEXP readItem() throws IOException {
   private SEXP readPersist(Flags flags) throws IOException {
     var strs = readStringVec();
     // Call the persistent hook on that strsxp
+    if (hook == null) {
+      throw new RDSException("No hook provided for PERSISTSXP");
+    }
     var res = hook.hook(strs);
     refTable.add(res);
     return res;
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index a9154e9e8..292b404a2 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -1,6 +1,5 @@
 package org.prlprg.session;
 
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
@@ -8,7 +7,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Set;
-import java.util.zip.InflaterInputStream;
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
 import org.prlprg.rds.RDSReader;
@@ -49,21 +47,24 @@ public void loadPackage(String name, String version) {
   }
 
   class EnvHook implements RDSReader.Hook {
-    private HashMap<String, VecSXP> references = new HashMap<>();
+    private HashMap<String, IntSXP> references = new HashMap<>();
     private InputStream in;
 
     EnvHook(VecSXP refs, InputStream in) {
       this.in = in;
       var names = refs.names();
       for (int i = 0; i < refs.size(); i++) {
-        this.references.put(names.get(i), (VecSXP) refs.get(i));
+        this.references.put(names.get(i), (IntSXP) refs.get(i));
       }
     }
 
     @Override
     public SEXP hook(SEXP sexp) {
       if (sexp instanceof StrSXP s) {
-        var position = references.getOrDefault(s.get(0), (VecSXP) sexp);
+        var position = references.get(s.get(0));
+        if (position == null) {
+          return sexp;
+        }
 
         // TODO: factorize with the other object reading function
         // And it looks like we cannot read linearly, can't we?
@@ -79,59 +80,8 @@ public SEXP hook(SEXP sexp) {
 
   public HashMap<String, SEXP> readPackageDatabase(Path path, String packageName)
       throws IOException {
-    // .libPaths and installed_packages() in R can help to see
-    // where packages are installed
-    var basePath = path.resolve(packageName + "/R");
-    // Read the index file .rdx
-    // we get a list with 3 elements, variables, references and compressed
-    // See LazyLoading in https://cran.r-project.org/doc/manuals/r-devel/R-ints.html
-    var index = RDSReader.readFile(this, basePath.resolve(packageName + ".rdx").toFile());
-
-    // Load objects .rdb
-    var objectFile = basePath.resolve(packageName + ".rdb").toFile();
-    try (var input = new FileInputStream(objectFile)) {
-
-      if (index instanceof VecSXP l) {
-        var variables = (VecSXP) l.get(0);
-        var names = variables.names();
-        var references = (VecSXP) l.get(1);
-        // Nowadays, it is always compressed. It can be a boolean,
-        // or an Int to indicate the compression algorithm: 2 bzip2, 3: xz
-        var compressed = l.get(2);
-        if (compressed instanceof IntSXP i) {
-          var algo =
-              switch (i.get(0)) {
-                case 2 -> "bzip2";
-                case 3 -> "xz";
-                default -> "unknown";
-              };
-          // For the other ones, there would be one more byte in addition to the length
-          // that would contain the compression method again or 0 if the compressed size
-          // had exceeded the uncompressed one.
-          throw new RuntimeException(algo + " compression detected; only zlib is supported");
-        }
-
-        var bindings = new HashMap<String, SEXP>(variables.size());
-
-        int offset = 0;
-        for (int i = 0; i < variables.size(); i++) {
-          var posInRdb = (IntSXP) variables.get(i);
-
-          input.skip(posInRdb.get(0) - offset);
-          offset = posInRdb.get(0);
-          byte[] len = input.readNBytes(4); // Skip the 4 bytes of the length
-          // convert to a 4 byte big endian int
-          int length = (len[0] << 24) | (len[1] << 16) | (len[2] << 8) | len[3];
-          // Read the object from the rdb file at the right positions
-          assert length + 4 == posInRdb.get(1) + 1;
-          var obj = RDSReader.readStream(this, new InflaterInputStream(input));
-          bindings.put(names.get(i), obj);
-        }
-        return bindings;
-      } else {
-        throw new RuntimeException("Invalid index file");
-      }
-    }
+    var db = new PackageDatabase(this, path, packageName);
+    return db.getBindings();
   }
 
   /**
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
new file mode 100644
index 000000000..7e5aa7255
--- /dev/null
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -0,0 +1,160 @@
+package org.prlprg.session;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.zip.InflaterInputStream;
+import org.prlprg.rds.RDSReader;
+import org.prlprg.sexp.IntSXP;
+import org.prlprg.sexp.SEXP;
+import org.prlprg.sexp.StrSXP;
+import org.prlprg.sexp.VecSXP;
+
+/**
+ * Read a package database. As described in the <a
+ * href="https://cran.r-project.org/doc/manuals/r-devel/R-ints.html#SEXPTYPEs">Lazy Loading</a>
+ * section of the R internals manual, the package database is located in the R subdirectory of the
+ * installed package and consists of two files: a compressed index file with the extension .rdx and
+ * a serialized object file with the extension .rdb.
+ *
+ * <p>This class can load object in the package on demand, and not all of them at once.
+ */
+public class PackageDatabase {
+  private RandomAccessFile objectFile;
+  private HashMap<String, IntSXP> index = new HashMap<>();
+  private HashMap<String, IntSXP> tmpEnvs = new HashMap<>();
+  private HashMap<String, SEXP> objects = new HashMap<>();
+  private RSession session;
+  private EnvHook envHook = new EnvHook();
+
+  private class EnvHook implements RDSReader.Hook {
+    @Override
+    public SEXP hook(SEXP sexp) throws IOException {
+      if (sexp instanceof StrSXP s) {
+        var position = tmpEnvs.get(s.get(0));
+        if (position == null) {
+          return sexp;
+        }
+
+        return readObject(s.get(0), tmpEnvs);
+      }
+
+      return sexp;
+    }
+  }
+
+  /**
+   * Create a new package database.
+   *
+   * @param libraryPath The path to the library where the package is installed.
+   * @param packageName The name of the package.
+   */
+  public PackageDatabase(RSession session, Path libraryPath, String packageName)
+      throws IOException {
+    this.session = session;
+    // .libPaths and installed_packages() in R can help to see
+    // where packages are installed
+    var basePath = libraryPath.resolve(packageName + "/R");
+    // Read the index file .rdx
+    // we get a list with 3 elements, variables, references and compressed
+    // See LazyLoading in https://cran.r-project.org/doc/manuals/r-devel/R-ints.html
+    var indexFile = RDSReader.readFile(session, basePath.resolve(packageName + ".rdx").toFile());
+
+    // Load objects .rdb
+    objectFile = new RandomAccessFile(String.valueOf(basePath.resolve(packageName + ".rdb")), "r");
+
+    // Read the index
+    if (indexFile instanceof VecSXP l) {
+      var variables = (VecSXP) l.get(0);
+      var references = (VecSXP) l.get(1);
+      var compressed = l.get(2);
+      if (compressed instanceof IntSXP i) {
+        var algo =
+            switch (i.get(0)) {
+              case 2 -> "bzip2";
+              case 3 -> "xz";
+              default -> "unknown";
+            };
+        // For the other ones, there would be one more byte in addition to the length
+        // that would contain the compression method again or 0 if the compressed size
+        // had exceeded the uncompressed one.
+        throw new RuntimeException(algo + " compression detected; only zlib is supported");
+      }
+
+      populateIndex(variables, index);
+      populateIndex(references, tmpEnvs);
+    } else {
+      throw new IllegalArgumentException("Invalid index file");
+    }
+  }
+
+  private static void populateIndex(VecSXP offsets, HashMap<String, IntSXP> offsetMap) {
+    var names = offsets.names();
+    for (int i = 0; i < offsets.size(); i++) {
+      var posInRdb = (IntSXP) offsets.get(i);
+      offsetMap.put(names.get(i), posInRdb);
+    }
+  }
+
+  /**
+   * Get the names of the symbols in the package database. It corresponds to the `variables` field
+   * in the index file (.rdb)
+   *
+   * @return
+   */
+  public Set<String> getSymbolNames() {
+    return index.keySet();
+  }
+
+  /**
+   * Get the object with the given name. This will look at the cache or read the rdb file and use
+   * the offset and length information from the index file to read the object.
+   *
+   * @param name
+   * @return
+   */
+  public SEXP getObject(String name) throws IOException {
+    return readObject(name, index);
+  }
+
+  private SEXP readObject(String name, HashMap<String, IntSXP> offsets) throws IOException {
+    var obj = objects.get(name);
+    if (obj != null) {
+      return obj;
+    }
+
+    var posInRdb = offsets.get(name);
+    objectFile.seek(posInRdb.get(0));
+    byte[] raw = new byte[posInRdb.get(1)];
+    objectFile.readFully(raw);
+    // The first 4 bytes are the uncompressed size for the chunk we read
+    // It is a big endian int
+    int length = (raw[0] << 24) | (raw[1] << 16) | (raw[2] << 8) | raw[3];
+    // assert length >= raw.length - 4;
+
+    var input = new ByteArrayInputStream(raw);
+    input.skipNBytes(4);
+    obj = RDSReader.readStream(session, new InflaterInputStream(input), envHook);
+
+    objects.put(name, obj);
+    return obj;
+  }
+
+  /**
+   * Get all the objects in the package database.
+   *
+   * @return
+   */
+  public HashMap<String, SEXP> getBindings() throws IOException {
+    if (objects.size() == index.size() + tmpEnvs.size()) {
+      return objects;
+    }
+    readObject(".__NAMESPACE__.", index);
+    for (var name : index.keySet()) {
+      readObject(name, index);
+    }
+    return objects;
+  }
+}

From b0cab6509707ff9366d334ef3e5437ead783877e Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 24 Jul 2024 18:20:47 +0200
Subject: [PATCH 20/80] WIP: adding basic ALTREP support (at least for ALTREP
 classes used in base)

---
 src/main/java/org/prlprg/rds/RDSReader.java   |  48 +++++++-
 .../java/org/prlprg/session/GNURSession.java  | 114 ++++++++++++------
 .../org/prlprg/session/PackageDatabase.java   |  19 +--
 src/main/java/org/prlprg/sexp/EnvSXP.java     |   4 +
 .../org/prlprg/rsession/GNURSessionTest.java  |  13 +-
 5 files changed, 146 insertions(+), 52 deletions(-)

diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index cebe61123..f4846c996 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -19,7 +19,6 @@
 import org.prlprg.primitive.Constants;
 import org.prlprg.primitive.Logical;
 import org.prlprg.session.RSession;
-import org.prlprg.sexp.*;
 import org.prlprg.sexp.Attributes;
 import org.prlprg.sexp.BCodeSXP;
 import org.prlprg.sexp.CloSXP;
@@ -48,7 +47,7 @@ public class RDSReader implements Closeable {
   private final RSession rsession;
   private final RDSInputStream in;
   private final List<SEXP> refTable = new ArrayList<>(128);
-  private final Logger logger = Logger.getLogger(RDSReader.class.getName());
+  private static Logger LOGGER = Logger.getLogger(RDSReader.class.getName());
 
   // User-provided hook for PERSISTSXP
   // Used for package databases for instance
@@ -121,7 +120,7 @@ private void readHeader() throws IOException {
     var formatVersion = in.readInt();
     if (formatVersion > 2) {
       // we do not completely support RDS version 3 because it uses ALTREP
-      logger.warning("RDS version: " + formatVersion + "; some features are not supported.");
+      // LOGGER.warning("RDS version: " + formatVersion + "; some features are not supported.");
     }
     // writer version
     in.readInt();
@@ -186,12 +185,53 @@ private SEXP readItem() throws IOException {
             case ATTRLANGSXP, ATTRLISTSXP -> throw new RDSException("Unexpected attr here");
             case UNBOUNDVALUE_SXP -> SEXPs.UNBOUND_VALUE;
             case PERSISTSXP -> readPersist(flags);
-            case GENERICREFSXP, PACKAGESXP, CLASSREFSXP, ALTREPSXP ->
+            case ALTREPSXP -> readAltRep(flags);
+            case GENERICREFSXP, PACKAGESXP, CLASSREFSXP ->
                 throw new RDSException("Unsupported RDS special type: " + s);
           };
     };
   }
 
+  private SEXP readAltRep(Flags flags) throws IOException {
+    // Info: serialized class (looks like it is also the attribute of the altrep object!)
+    // Info is a 3 element list: class name, package name, type
+    var info = (ListSXP) readItem();
+    var state = readItem();
+    var attributes = readItem();
+
+    var className = ((RegSymSXP) info.get(0).value()).name();
+    var packageName = ((RegSymSXP) info.get(1).value()).name();
+    var type = SEXPType.valueOf(((IntSXP) info.get(2).value()).get(0));
+
+    // Alt classes used in base are defined here:
+    // https://github.com/wch/r-source/blob/abaa89600f4f024a80121ebb95fc4d80ea0a9b12/src/main/altclasses.c
+
+    LOGGER.info(
+        "Reading ALTREP with class "
+            + className
+            + " from package "
+            + packageName
+            + " with type "
+            + type);
+
+    // Dummy, just to test
+    // TODO: implement for at least int and real compact sequences.
+    // If you have R installed on a Linux machine,
+    // then running testLoadBase should log the necessary altrep classes
+    return switch (type) {
+      case INT -> SEXPs.integer(0);
+      case REAL -> SEXPs.real(0.0);
+      case STR -> SEXPs.string("hello world");
+      case LGL -> SEXPs.logical(Logical.NA);
+      case VEC -> SEXPs.vec();
+      case CPLX -> SEXPs.complex(0, 0);
+      case RAW -> SEXPs.raw((byte) 0);
+      default -> throw new RDSException("ALTREP type not supported: " + type);
+    };
+
+    // throw new RDSException("ALTREP not supported");
+  }
+
   private SEXP readPersist(Flags flags) throws IOException {
     var strs = readStringVec();
     // Call the persistent hook on that strsxp
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index 292b404a2..5237ba716 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -1,23 +1,70 @@
 package org.prlprg.session;
 
 import java.io.IOException;
-import java.io.InputStream;
 import java.net.URI;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.server.Messages;
 import org.prlprg.sexp.*;
 
+/**
+ * Dummy session used to bootstrap base. Indeed, the RDS reader that reads base package database
+ * requires a session.
+ */
+class DummySession implements RSession {
+  private final Logger logger = Logger.getLogger(DummySession.class.getName());
+  private final GlobalEnvSXP globalEnv = new GlobalEnvSXP(SEXPs.EMPTY_ENV);
+  private final NamespaceEnvSXP namespaceEnv =
+      new NamespaceEnvSXP("base", "4.3.2", globalEnv, new HashMap<>());
+  private final BaseEnvSXP baseEnv = new BaseEnvSXP(new HashMap<>());
+
+  @Override
+  public NamespaceEnvSXP baseNamespace() {
+    return namespaceEnv;
+  }
+
+  @Override
+  public BaseEnvSXP baseEnv() {
+    return baseEnv;
+  }
+
+  @Override
+  public GlobalEnvSXP globalEnv() {
+    return globalEnv;
+  }
+
+  @Override
+  public boolean isBuiltin(String name) {
+    return false;
+  }
+
+  @Override
+  public boolean isSpecial(String name) {
+    return false;
+  }
+
+  @Override
+  public boolean isBuiltinInternal(String name) {
+    return false;
+  }
+
+  @Override
+  public NamespaceEnvSXP getNamespace(String name, String version) {
+    return null;
+  }
+}
+
 public class GNURSession implements RSession {
   private URI cranMirror;
   private org.prlprg.RVersion RVersion;
 
-  private @Nullable BaseEnvSXP baseEnvSXP = null;
+  private @Nullable BaseEnvSXP baseEnv = null;
   private @Nullable NamespaceEnvSXP baseNamespace = null;
   private @Nullable GlobalEnvSXP globalEnv = null;
   private @Nullable Set<String> builtins = null;
@@ -46,41 +93,9 @@ public void loadPackage(String name, String version) {
     // Or rather do lazy loading like R?
   }
 
-  class EnvHook implements RDSReader.Hook {
-    private HashMap<String, IntSXP> references = new HashMap<>();
-    private InputStream in;
-
-    EnvHook(VecSXP refs, InputStream in) {
-      this.in = in;
-      var names = refs.names();
-      for (int i = 0; i < refs.size(); i++) {
-        this.references.put(names.get(i), (IntSXP) refs.get(i));
-      }
-    }
-
-    @Override
-    public SEXP hook(SEXP sexp) {
-      if (sexp instanceof StrSXP s) {
-        var position = references.get(s.get(0));
-        if (position == null) {
-          return sexp;
-        }
-
-        // TODO: factorize with the other object reading function
-        // And it looks like we cannot read linearly, can't we?
-        // or we need first to merge the symbols and the temp environments in offset increasing
-        // order
-        // and then load in order.
-        return sexp;
-      }
-
-      return sexp;
-    }
-  }
-
-  public HashMap<String, SEXP> readPackageDatabase(Path path, String packageName)
-      throws IOException {
-    var db = new PackageDatabase(this, path, packageName);
+  public static HashMap<String, SEXP> readPackageDatabase(
+      RSession session, Path path, String packageName) throws IOException {
+    var db = new PackageDatabase(session, path, packageName);
     return db.getBindings();
   }
 
@@ -124,21 +139,40 @@ public EnvSXP loadPackage(String name, String version, List<Messages.Function> f
    */
   public void loadBase(List<Messages.Function> functions) {
     // TODO
+    // Bootstrap the reader with an ad-hoc session?
+  }
+
+  /** Load base from the given installed R version */
+  public void loadBase(Path r_lib) throws IOException {
+    var session = new DummySession();
+    var objs = GNURSession.readPackageDatabase(session, r_lib, "base");
+    // TODO: write the right version of R (extract ot from the path?)
+    baseNamespace = new NamespaceEnvSXP("base", "4.3.2", this.globalEnv(), objs);
+    baseEnv = new BaseEnvSXP(objs);
   }
 
   @Override
   public NamespaceEnvSXP baseNamespace() {
-    return null;
+    if (baseNamespace == null) {
+      // loadBase();
+    }
+    return baseNamespace;
   }
 
   @Override
   public BaseEnvSXP baseEnv() {
-    return null;
+    if (baseEnv == null) {
+      // loadBase();
+    }
+    return baseEnv;
   }
 
   @Override
   public GlobalEnvSXP globalEnv() {
-    return null;
+    if (globalEnv == null) {
+      globalEnv = new GlobalEnvSXP(baseEnv());
+    }
+    return globalEnv;
   }
 
   @Override
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index 7e5aa7255..061ba78fb 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -5,6 +5,7 @@
 import java.io.RandomAccessFile;
 import java.nio.file.Path;
 import java.util.*;
+import java.util.logging.Logger;
 import java.util.zip.InflaterInputStream;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.sexp.IntSXP;
@@ -22,12 +23,13 @@
  * <p>This class can load object in the package on demand, and not all of them at once.
  */
 public class PackageDatabase {
-  private RandomAccessFile objectFile;
-  private HashMap<String, IntSXP> index = new HashMap<>();
-  private HashMap<String, IntSXP> tmpEnvs = new HashMap<>();
-  private HashMap<String, SEXP> objects = new HashMap<>();
-  private RSession session;
-  private EnvHook envHook = new EnvHook();
+  private static Logger LOGGER = Logger.getLogger(PackageDatabase.class.getName());
+  private final RandomAccessFile objectFile;
+  private final HashMap<String, IntSXP> index = new HashMap<>();
+  private final HashMap<String, IntSXP> tmpEnvs = new HashMap<>();
+  private final HashMap<String, SEXP> objects = new HashMap<>();
+  private final RSession session;
+  private final EnvHook envHook = new EnvHook();
 
   private class EnvHook implements RDSReader.Hook {
     @Override
@@ -151,8 +153,11 @@ public HashMap<String, SEXP> getBindings() throws IOException {
     if (objects.size() == index.size() + tmpEnvs.size()) {
       return objects;
     }
-    readObject(".__NAMESPACE__.", index);
+    if (index.containsKey(".__NAMESPACE__.")) {
+      readObject(".__NAMESPACE__.", index);
+    }
     for (var name : index.keySet()) {
+      LOGGER.info("Loading " + name);
       readObject(name, index);
     }
     return objects;
diff --git a/src/main/java/org/prlprg/sexp/EnvSXP.java b/src/main/java/org/prlprg/sexp/EnvSXP.java
index 84bfdfb75..681e9f607 100644
--- a/src/main/java/org/prlprg/sexp/EnvSXP.java
+++ b/src/main/java/org/prlprg/sexp/EnvSXP.java
@@ -56,6 +56,10 @@ public sealed interface EnvSXP extends SEXP permits StaticEnvSXP, UserEnvSXP {
    */
   int size();
 
+  default boolean isEmpty() {
+    return size() == 0;
+  }
+
   @Override
   default SEXPType type() {
     return SEXPType.ENV;
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 76905781c..879302c0d 100644
--- a/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -8,13 +8,24 @@
 import org.prlprg.session.GNURSession;
 
 public class GNURSessionTest {
+  private static final String R_HOME = System.getenv("R_HOME");
+
   @Test
   public void testReadPackageDatabase() throws IOException {
     var session = new GNURSession(RVersion.LATEST_AWARE, null);
     var p = "~/R/x86_64-pc-linux-gnu-library/4.3/";
     p = p.replaceFirst("^~", System.getProperty("user.home"));
-    var funs = session.readPackageDatabase(Path.of(p), "yaml");
+    var funs = GNURSession.readPackageDatabase(session, Path.of(p), "yaml");
 
     Assertions.assertFalse(funs.isEmpty());
   }
+
+  @Test
+  public void testLoadBase() throws IOException {
+    var session = new GNURSession(RVersion.LATEST_AWARE, null);
+    var p = "/usr/lib/R/library";
+    session.loadBase(Path.of(p));
+
+    Assertions.assertFalse(session.baseNamespace().isEmpty());
+  }
 }

From 208a102bd4219a55b3a47cb278fb92b0fae3c3c8 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 25 Jul 2024 18:19:23 +0200
Subject: [PATCH 21/80] WIP: AltRep unserialization support for base function

---
 src/main/java/org/prlprg/rds/AltRep.java      | 72 +++++++++++++++++++
 src/main/java/org/prlprg/rds/RDSReader.java   |  3 +-
 .../org/prlprg/session/PackageDatabase.java   | 17 +++--
 src/main/java/org/prlprg/sexp/SEXP.java       | 12 ++--
 4 files changed, 92 insertions(+), 12 deletions(-)
 create mode 100644 src/main/java/org/prlprg/rds/AltRep.java

diff --git a/src/main/java/org/prlprg/rds/AltRep.java b/src/main/java/org/prlprg/rds/AltRep.java
new file mode 100644
index 000000000..dab6b5280
--- /dev/null
+++ b/src/main/java/org/prlprg/rds/AltRep.java
@@ -0,0 +1,72 @@
+package org.prlprg.rds;
+
+import java.util.stream.IntStream;
+import org.prlprg.sexp.*;
+
+interface AltRep {
+  SEXPType getType();
+
+  String getClassName();
+
+  String getPackageName();
+
+  SEXP unserialize(SEXP state);
+}
+
+class AltRepUnserializer {
+  private final String className;
+  private final String packageName;
+  private final SEXPType type;
+  private final SEXP state;
+
+  public AltRepUnserializer(ListSXP info, SEXP state) {
+    className = ((RegSymSXP) info.get(0).value()).name();
+    packageName = ((RegSymSXP) info.get(1).value()).name();
+    type = SEXPType.valueOf(((IntSXP) info.get(2).value()).get(0));
+
+    this.state = state;
+  }
+
+  public void addAltRep(AltRep altRepClass) {
+    throw new UnsupportedOperationException("Not implemented");
+  }
+
+  public SEXP unserialize() {
+    throw new UnsupportedOperationException("Not implemented");
+  }
+}
+
+class IntCompactSeq implements AltRep {
+
+  @Override
+  public SEXPType getType() {
+    return SEXPType.INT;
+  }
+
+  @Override
+  public String getClassName() {
+    return "compact_seq_int";
+  }
+
+  @Override
+  public String getPackageName() {
+    return "base";
+  }
+
+  @Override
+  public SEXP unserialize(SEXP state) {
+    var l = (ListSXP) state;
+    var length = ((IntSXP) l.get(0).value()).get(0);
+    var start = ((IntSXP) l.get(1).value()).get(0);
+    var direction = ((IntSXP) l.get(2).value()).get(0);
+
+    if (direction == 1) {
+      return SEXPs.integer(IntStream.rangeClosed(start, start + length).toArray());
+    } else {
+      return SEXPs.integer(
+          IntStream.rangeClosed(start - length, start)
+              .map(i -> start - length + (start - 1 - i))
+              .toArray());
+    }
+  }
+}
diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index f4846c996..168e1609a 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -676,7 +676,8 @@ private ListSXP readList(Flags flags) throws IOException {
 
   private CloSXP readClosure(Flags flags) throws IOException {
     var attributes = readAttributes(flags);
-    if (!(readItem() instanceof EnvSXP env)) {
+    var item = readItem();
+    if (!(item instanceof EnvSXP env)) {
       throw new RDSException("Expected CLOENV to be environment");
     }
     if (!(readItem() instanceof ListSXP formals)) {
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index 061ba78fb..8df070103 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -8,10 +8,7 @@
 import java.util.logging.Logger;
 import java.util.zip.InflaterInputStream;
 import org.prlprg.rds.RDSReader;
-import org.prlprg.sexp.IntSXP;
-import org.prlprg.sexp.SEXP;
-import org.prlprg.sexp.StrSXP;
-import org.prlprg.sexp.VecSXP;
+import org.prlprg.sexp.*;
 
 /**
  * Read a package database. As described in the <a
@@ -30,6 +27,7 @@ public class PackageDatabase {
   private final HashMap<String, SEXP> objects = new HashMap<>();
   private final RSession session;
   private final EnvHook envHook = new EnvHook();
+  private final Set<String> seenTmpEnvs = new HashSet<>();
 
   private class EnvHook implements RDSReader.Hook {
     @Override
@@ -39,6 +37,15 @@ public SEXP hook(SEXP sexp) throws IOException {
         if (position == null) {
           return sexp;
         }
+        // There is a cycle in the Env!
+        if (seenTmpEnvs.contains(s.get(0))) {
+          // create a placeholder environment, which we will replace later
+          // by the actual environment
+          return new NamespaceEnvSXP(
+              s.get(0), "placeholder", session.baseNamespace(), new HashMap<>());
+        }
+
+        seenTmpEnvs.add(s.get(0));
 
         return readObject(s.get(0), tmpEnvs);
       }
@@ -157,7 +164,7 @@ public HashMap<String, SEXP> getBindings() throws IOException {
       readObject(".__NAMESPACE__.", index);
     }
     for (var name : index.keySet()) {
-      LOGGER.info("Loading " + name);
+      // LOGGER.info("Loading " + name);
       readObject(name, index);
     }
     return objects;
diff --git a/src/main/java/org/prlprg/sexp/SEXP.java b/src/main/java/org/prlprg/sexp/SEXP.java
index 0c74e6f13..54941d8a8 100644
--- a/src/main/java/org/prlprg/sexp/SEXP.java
+++ b/src/main/java/org/prlprg/sexp/SEXP.java
@@ -26,15 +26,15 @@
  * suspect GNU-R SEXPs aren't actually S-expressions.
  */
 public sealed interface SEXP
-    permits StrOrRegSymSXP,
-        SymOrLangSXP,
-        ListOrVectorSXP,
-        LangOrListSXP,
+    permits BCodeSXP,
+        BuiltinOrSpecialSXP,
         CloSXP,
         EnvSXP,
-        BCodeSXP,
+        LangOrListSXP,
+        ListOrVectorSXP,
         PromSXP,
-        BuiltinOrSpecialSXP {
+        StrOrRegSymSXP,
+        SymOrLangSXP {
   /**
    * SEXPTYPE. It's important to distinguish these from the SEXP's class, because there's a class
    * for every type but not vice versa due to subclasses (e.g. simple-scalar ints have the same

From 6f840ddd103252d21d27e5abfc4539af7b74ed40 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 26 Jul 2024 14:46:53 +0200
Subject: [PATCH 22/80] Correctly unserializing AltRep compact_intseq

---
 src/main/java/org/prlprg/rds/AltRep.java      | 72 +++++++++----------
 src/main/java/org/prlprg/rds/BaseAltrRep.java | 45 ++++++++++++
 src/main/java/org/prlprg/rds/RDSReader.java   | 35 +--------
 .../org/prlprg/session/PackageDatabase.java   | 27 ++++++-
 4 files changed, 108 insertions(+), 71 deletions(-)
 create mode 100644 src/main/java/org/prlprg/rds/BaseAltrRep.java

diff --git a/src/main/java/org/prlprg/rds/AltRep.java b/src/main/java/org/prlprg/rds/AltRep.java
index dab6b5280..d863a23ee 100644
--- a/src/main/java/org/prlprg/rds/AltRep.java
+++ b/src/main/java/org/prlprg/rds/AltRep.java
@@ -1,6 +1,7 @@
 package org.prlprg.rds;
 
-import java.util.stream.IntStream;
+import java.util.HashMap;
+import java.util.logging.Logger;
 import org.prlprg.sexp.*;
 
 interface AltRep {
@@ -14,59 +15,54 @@ interface AltRep {
 }
 
 class AltRepUnserializer {
+  private static Logger LOGGER = Logger.getLogger(AltRepUnserializer.class.getName());
   private final String className;
   private final String packageName;
   private final SEXPType type;
   private final SEXP state;
 
+  private static HashMap<String, AltRep> altReps = new HashMap<String, AltRep>();
+
+  static {
+    // Add here all the alt reps you want to support
+    addAltRep(new BaseAltrRep.CompactIntSeq());
+  }
+
   public AltRepUnserializer(ListSXP info, SEXP state) {
     className = ((RegSymSXP) info.get(0).value()).name();
     packageName = ((RegSymSXP) info.get(1).value()).name();
     type = SEXPType.valueOf(((IntSXP) info.get(2).value()).get(0));
 
+    LOGGER.info(
+        "Reading ALTREP with class "
+            + className
+            + " from package "
+            + packageName
+            + " with type "
+            + type);
+
     this.state = state;
   }
 
-  public void addAltRep(AltRep altRepClass) {
-    throw new UnsupportedOperationException("Not implemented");
+  public static void addAltRep(AltRep altRepClass) {
+    altReps.put(
+        altRepClass.getClassName() + altRepClass.getPackageName() + altRepClass.getType(),
+        altRepClass);
   }
 
   public SEXP unserialize() {
-    throw new UnsupportedOperationException("Not implemented");
-  }
-}
-
-class IntCompactSeq implements AltRep {
-
-  @Override
-  public SEXPType getType() {
-    return SEXPType.INT;
-  }
-
-  @Override
-  public String getClassName() {
-    return "compact_seq_int";
-  }
-
-  @Override
-  public String getPackageName() {
-    return "base";
-  }
-
-  @Override
-  public SEXP unserialize(SEXP state) {
-    var l = (ListSXP) state;
-    var length = ((IntSXP) l.get(0).value()).get(0);
-    var start = ((IntSXP) l.get(1).value()).get(0);
-    var direction = ((IntSXP) l.get(2).value()).get(0);
-
-    if (direction == 1) {
-      return SEXPs.integer(IntStream.rangeClosed(start, start + length).toArray());
-    } else {
-      return SEXPs.integer(
-          IntStream.rangeClosed(start - length, start)
-              .map(i -> start - length + (start - 1 - i))
-              .toArray());
+    var altRep = altReps.get(className + packageName + type);
+    if (altRep == null) {
+      throw new UnsupportedOperationException(
+          "AltRep "
+              + className
+              + " in package "
+              + packageName
+              + " for type "
+              + type
+              + " not implemented");
     }
+
+    return altRep.unserialize(state);
   }
 }
diff --git a/src/main/java/org/prlprg/rds/BaseAltrRep.java b/src/main/java/org/prlprg/rds/BaseAltrRep.java
new file mode 100644
index 000000000..3811c4835
--- /dev/null
+++ b/src/main/java/org/prlprg/rds/BaseAltrRep.java
@@ -0,0 +1,45 @@
+package org.prlprg.rds;
+
+import java.util.stream.IntStream;
+import org.prlprg.sexp.*;
+
+/**
+ * For all the altrep classes defined for base. See: <a
+ * href="https://github.com/wch/r-source/blob/abaa89600f4f024a80121ebb95fc4d80ea0a9b12/src/main/altclasses.c">...</a>
+ */
+public class BaseAltrRep {
+  public static class CompactIntSeq implements AltRep {
+
+    @Override
+    public SEXPType getType() {
+      return SEXPType.INT;
+    }
+
+    @Override
+    public String getClassName() {
+      return "compact_intseq";
+    }
+
+    @Override
+    public String getPackageName() {
+      return "base";
+    }
+
+    @Override
+    public SEXP unserialize(SEXP state) {
+      var l = (RealSXP) state;
+      var length = l.get(0).intValue(); // we might need a double there though
+      var start = l.get(1).intValue();
+      var direction = l.get(2).intValue();
+
+      if (direction == 1) {
+        return SEXPs.integer(IntStream.rangeClosed(start, start + length).toArray());
+      } else {
+        return SEXPs.integer(
+            IntStream.rangeClosed(start - length, start)
+                .map(i -> start - length + (start - 1 - i))
+                .toArray());
+      }
+    }
+  }
+}
diff --git a/src/main/java/org/prlprg/rds/RDSReader.java b/src/main/java/org/prlprg/rds/RDSReader.java
index 168e1609a..0e536d668 100644
--- a/src/main/java/org/prlprg/rds/RDSReader.java
+++ b/src/main/java/org/prlprg/rds/RDSReader.java
@@ -197,39 +197,10 @@ private SEXP readAltRep(Flags flags) throws IOException {
     // Info is a 3 element list: class name, package name, type
     var info = (ListSXP) readItem();
     var state = readItem();
-    var attributes = readItem();
-
-    var className = ((RegSymSXP) info.get(0).value()).name();
-    var packageName = ((RegSymSXP) info.get(1).value()).name();
-    var type = SEXPType.valueOf(((IntSXP) info.get(2).value()).get(0));
-
-    // Alt classes used in base are defined here:
-    // https://github.com/wch/r-source/blob/abaa89600f4f024a80121ebb95fc4d80ea0a9b12/src/main/altclasses.c
-
-    LOGGER.info(
-        "Reading ALTREP with class "
-            + className
-            + " from package "
-            + packageName
-            + " with type "
-            + type);
-
-    // Dummy, just to test
-    // TODO: implement for at least int and real compact sequences.
-    // If you have R installed on a Linux machine,
-    // then running testLoadBase should log the necessary altrep classes
-    return switch (type) {
-      case INT -> SEXPs.integer(0);
-      case REAL -> SEXPs.real(0.0);
-      case STR -> SEXPs.string("hello world");
-      case LGL -> SEXPs.logical(Logical.NA);
-      case VEC -> SEXPs.vec();
-      case CPLX -> SEXPs.complex(0, 0);
-      case RAW -> SEXPs.raw((byte) 0);
-      default -> throw new RDSException("ALTREP type not supported: " + type);
-    };
+    var attributes = readAttributes();
 
-    // throw new RDSException("ALTREP not supported");
+    var sexp = new AltRepUnserializer(info, state).unserialize();
+    return sexp.withAttributes(attributes);
   }
 
   private SEXP readPersist(Flags flags) throws IOException {
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index 8df070103..482ea5fc7 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -7,6 +7,7 @@
 import java.util.*;
 import java.util.logging.Logger;
 import java.util.zip.InflaterInputStream;
+import org.prlprg.rds.RDSException;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.sexp.*;
 
@@ -163,9 +164,33 @@ public HashMap<String, SEXP> getBindings() throws IOException {
     if (index.containsKey(".__NAMESPACE__.")) {
       readObject(".__NAMESPACE__.", index);
     }
+
+    // Problems:
+    // - .doSortWrap : cycle in with env:4
+    // - parseNamespaceFile : index out of bound when reading bytecode
+    // - globalCallingHandlers : same as .doSortWrap
+    // - conflictRules : same
+    // - doWrap: same
+    // - summary.default: malformed bytecode
+    // - .dynLibs: cycle with env:4
+    // - .libPaths: same
+    HashSet<String> forbiddenFunctions = new HashSet<>();
+    forbiddenFunctions.add(".doSortWrap");
+    forbiddenFunctions.add("parseNamespaceFile");
+    forbiddenFunctions.add("globalCallingHandlers");
+    forbiddenFunctions.add("conflictRules");
+    forbiddenFunctions.add(".doWrap");
+
     for (var name : index.keySet()) {
       // LOGGER.info("Loading " + name);
-      readObject(name, index);
+
+      if (!forbiddenFunctions.contains(name)) {
+        try {
+          readObject(name, index);
+        } catch (RDSException e) {
+          LOGGER.warning("Error loading " + name + ": " + e.getMessage());
+        }
+      }
     }
     return objects;
   }

From fa18941c6a2bd21915668806c1c819aca5dd3ff5 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 30 Jul 2024 18:29:51 +0200
Subject: [PATCH 23/80] Correctly read non special environments referred by
 PersistSXP in a package database.

Also deals with the cycles!
---
 src/main/java/org/prlprg/rds/AltRep.java      |  14 +-
 .../org/prlprg/session/PackageDatabase.java   | 144 +++++++++++++++---
 2 files changed, 130 insertions(+), 28 deletions(-)

diff --git a/src/main/java/org/prlprg/rds/AltRep.java b/src/main/java/org/prlprg/rds/AltRep.java
index d863a23ee..b0782d6e3 100644
--- a/src/main/java/org/prlprg/rds/AltRep.java
+++ b/src/main/java/org/prlprg/rds/AltRep.java
@@ -33,13 +33,13 @@ public AltRepUnserializer(ListSXP info, SEXP state) {
     packageName = ((RegSymSXP) info.get(1).value()).name();
     type = SEXPType.valueOf(((IntSXP) info.get(2).value()).get(0));
 
-    LOGGER.info(
-        "Reading ALTREP with class "
-            + className
-            + " from package "
-            + packageName
-            + " with type "
-            + type);
+    //    LOGGER.info(
+    //        "Reading ALTREP with class "
+    //            + className
+    //            + " from package "
+    //            + packageName
+    //            + " with type "
+    //            + type);
 
     this.state = state;
   }
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index 482ea5fc7..8ce5c95d6 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -34,27 +34,130 @@ private class EnvHook implements RDSReader.Hook {
     @Override
     public SEXP hook(SEXP sexp) throws IOException {
       if (sexp instanceof StrSXP s) {
-        var position = tmpEnvs.get(s.get(0));
+        var name = s.get(0);
+        var position = tmpEnvs.get(name);
         if (position == null) {
           return sexp;
         }
         // There is a cycle in the Env!
-        if (seenTmpEnvs.contains(s.get(0))) {
+        if (seenTmpEnvs.contains(name)) {
           // create a placeholder environment, which we will replace later
           // by the actual environment
           return new NamespaceEnvSXP(
-              s.get(0), "placeholder", session.baseNamespace(), new HashMap<>());
+              // add a binding which would be the parent SEXP?
+              name, "__placeholder__", session.baseNamespace(), new HashMap<>());
         }
 
-        seenTmpEnvs.add(s.get(0));
+        seenTmpEnvs.add(name);
+        // env::4, env::10, env::9 are not environments but VecSXP!
+        // We should convert them to environments.
+        // They are created when the function was defined using `local`
+        // But more generally, any non special env (i.e, not global, namespace, base etc)
+        // is serialized to a VecSXP in the rdb file.
+        var tmpEnv = readObject(name, tmpEnvs);
+        if (tmpEnv instanceof VecSXP v) {
+          var realEnv = vecToEnv(v);
+          replacePlaceHolder(realEnv, tmpEnv, name);
+          return realEnv;
+        }
 
-        return readObject(s.get(0), tmpEnvs);
+        return tmpEnv;
       }
 
       return sexp;
     }
   }
 
+  /**
+   * Find occurrences of all placeholder environments, that we added when reading back environments
+   * with cycles and put back the cycle. Placeholder envs are NamespaceEnv with "__placeholder__" as
+   * version and the original env::n as name. We have to do this 2-step dance here because we first
+   * need to build the environment before putting a reference to it inside itself!
+   *
+   * @param selfRefEnv the environment that we want to make refer to itself
+   * @param v the sexp on which we currently recurse
+   * @param name the name of the environment used in the placeholder
+   */
+  private static void replacePlaceHolder(UserEnvSXP selfRefEnv, SEXP v, String name) {
+    switch (v) {
+      case EnvSXP env -> {
+        for (var e : env.bindings()) {
+          if (e.getValue() instanceof EnvSXP e2) {
+            if (e2 instanceof NamespaceEnvSXP n) {
+              if (n.version().equals("__placeholder__") && n.name().equals(name)) {
+                e.setValue(selfRefEnv);
+              }
+            } else {
+              replacePlaceHolder(selfRefEnv, e2, name);
+            }
+          }
+        }
+      }
+      case VecSXP vec -> {
+        for (var e : vec) {
+          // There could also be the placeholder here, but that's unlikely
+          if (e instanceof NamespaceEnvSXP n) {
+            if (n.version().equals("__placeholder__") && n.name().equals(name)) {
+              LOGGER.warning("Unexpected cycle placeholder in a list.");
+            }
+          }
+          replacePlaceHolder(selfRefEnv, e, name);
+        }
+      }
+      case CloSXP clo when clo.env() instanceof NamespaceEnvSXP n
+          && n.version().equals("__placeholder__")
+          && n.name().equals(name) -> {
+        // we need to set up that environment to selfRefEnv
+        // but because of our practically immutable SEXPs, we would have to modify its parent
+      }
+      case CloSXP clo -> replacePlaceHolder(selfRefEnv, clo.env(), name);
+      default -> {}
+    }
+  }
+
+  /**
+   * Envs that are not special environments are serialized as VecSXP, with a specific shape. Here,
+   * we transform them back into EnvSXP
+   *
+   * <p>See makebasedb.R or makelazyload.R
+   *
+   * <p>- <a
+   * href="https://github.com/SurajGupta/r-source/blob/a28e609e72ed7c47f6ddfbb86c85279a0750f0b7/src/library/base/makebasedb.R#L69">makebasedb</a>
+   * - <a
+   * href="https://github.com/SurajGupta/r-source/blob/a28e609e72ed7c47f6ddfbb86c85279a0750f0b7/src/library/tools/R/makeLazyLoad.R">makelazyload</a>
+   *
+   * @param v
+   * @return
+   */
+  private static UserEnvSXP vecToEnv(VecSXP v) {
+    /*
+     env is a list with 2 elements with names:
+     - `bindings`: all the symbols in the environment (names + value)
+     - `enclos`: the parent environment
+    */
+    // Check if the names are correct
+    var names = (StrSXP) v.attributes().get("names");
+    assert Objects.requireNonNull(names).get(0).equals("bindings");
+    assert names.get(1).equals("enclos");
+
+    // Enclos
+    var enclos = (EnvSXP) v.get(1);
+
+    // Bindings
+    var symbols = (VecSXP) v.get(0);
+    names = (StrSXP) symbols.attributes().get("names");
+    assert names != null;
+    var bindings = new HashMap<String, SEXP>();
+    for (int i = 0; i < symbols.size(); i++) {
+      var name = names.get(i);
+      assert name != null;
+      var value = symbols.get(i);
+      bindings.put(name, value);
+    }
+
+    return new UserEnvSXP(enclos, bindings);
+  }
+
   /**
    * Create a new package database.
    *
@@ -167,31 +270,30 @@ public HashMap<String, SEXP> getBindings() throws IOException {
 
     // Problems:
     // - .doSortWrap : cycle in with env:4
-    // - parseNamespaceFile : index out of bound when reading bytecode
     // - globalCallingHandlers : same as .doSortWrap
     // - conflictRules : same
-    // - doWrap: same
-    // - summary.default: malformed bytecode
+    // - .doWrap : same (but it seems it depends on the order of the symbol reading
     // - .dynLibs: cycle with env:4
     // - .libPaths: same
-    HashSet<String> forbiddenFunctions = new HashSet<>();
-    forbiddenFunctions.add(".doSortWrap");
-    forbiddenFunctions.add("parseNamespaceFile");
-    forbiddenFunctions.add("globalCallingHandlers");
-    forbiddenFunctions.add("conflictRules");
-    forbiddenFunctions.add(".doWrap");
-
     for (var name : index.keySet()) {
       // LOGGER.info("Loading " + name);
 
-      if (!forbiddenFunctions.contains(name)) {
-        try {
-          readObject(name, index);
-        } catch (RDSException e) {
-          LOGGER.warning("Error loading " + name + ": " + e.getMessage());
-        }
+      try {
+        readObject(name, index);
+      } catch (RDSException e) {
+        LOGGER.warning("Error loading " + name + ": " + e.getMessage());
       }
     }
+
+    var notClos =
+        objects.entrySet().stream()
+            .filter(e -> !(e.getValue() instanceof CloSXP))
+            .map(e -> e.getKey() + ":" + e.getValue().type())
+            .toList();
+    LOGGER.info("Not Closures: " + notClos);
+
+    // TODO: filter out the env::n
+
     return objects;
   }
 }

From 5ec89702b3f945047ceffee3f957dae611e36664 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 31 Jul 2024 16:21:42 +0200
Subject: [PATCH 24/80] PERSISTSXP envs: correctly add cycles back

---
 .../org/prlprg/session/PackageDatabase.java   | 62 +++++++++++--------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index 8ce5c95d6..b157c8f39 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -57,7 +57,7 @@ public SEXP hook(SEXP sexp) throws IOException {
         var tmpEnv = readObject(name, tmpEnvs);
         if (tmpEnv instanceof VecSXP v) {
           var realEnv = vecToEnv(v);
-          replacePlaceHolder(realEnv, tmpEnv, name);
+          realEnv = (UserEnvSXP) replacePlaceHolder(realEnv, realEnv, name);
           return realEnv;
         }
 
@@ -77,42 +77,52 @@ public SEXP hook(SEXP sexp) throws IOException {
    * @param selfRefEnv the environment that we want to make refer to itself
    * @param v the sexp on which we currently recurse
    * @param name the name of the environment used in the placeholder
+   * @return the sexp with the placeholder replaced by the actual environment
    */
-  private static void replacePlaceHolder(UserEnvSXP selfRefEnv, SEXP v, String name) {
-    switch (v) {
+  private static SEXP replacePlaceHolder(UserEnvSXP selfRefEnv, SEXP v, String name) {
+    // FIXME: there could also be environments in attributes
+    return switch (v) {
+      case NamespaceEnvSXP n -> {
+        if (n.version().equals("__placeholder__") && n.name().equals(name)) {
+          yield selfRefEnv;
+        } else {
+          yield n;
+        }
+      }
       case EnvSXP env -> {
         for (var e : env.bindings()) {
-          if (e.getValue() instanceof EnvSXP e2) {
-            if (e2 instanceof NamespaceEnvSXP n) {
-              if (n.version().equals("__placeholder__") && n.name().equals(name)) {
-                e.setValue(selfRefEnv);
-              }
-            } else {
-              replacePlaceHolder(selfRefEnv, e2, name);
-            }
+          var res = replacePlaceHolder(selfRefEnv, e.getValue(), name);
+          if (res != e.getValue()) {
+            env.set(e.getKey(), res);
           }
         }
+        yield env;
       }
       case VecSXP vec -> {
-        for (var e : vec) {
-          // There could also be the placeholder here, but that's unlikely
-          if (e instanceof NamespaceEnvSXP n) {
-            if (n.version().equals("__placeholder__") && n.name().equals(name)) {
-              LOGGER.warning("Unexpected cycle placeholder in a list.");
-            }
+        SEXP[] res = new SEXP[vec.size()];
+        boolean change = false;
+        for (int i = 0; i < vec.size(); i++) {
+          res[i] = replacePlaceHolder(selfRefEnv, vec.get(i), name);
+          if (res[i] != vec.get(i)) {
+            change = true;
           }
-          replacePlaceHolder(selfRefEnv, e, name);
+        }
+        if (change) {
+          yield SEXPs.vec(res, vec.attributes());
+        } else {
+          yield vec;
         }
       }
-      case CloSXP clo when clo.env() instanceof NamespaceEnvSXP n
-          && n.version().equals("__placeholder__")
-          && n.name().equals(name) -> {
-        // we need to set up that environment to selfRefEnv
-        // but because of our practically immutable SEXPs, we would have to modify its parent
+      case CloSXP clo -> {
+        var res = replacePlaceHolder(selfRefEnv, clo.env(), name);
+        if (res != clo.env()) {
+          yield SEXPs.closure(clo.parameters(), clo.body(), (EnvSXP) res, clo.attributes());
+        } else {
+          yield clo;
+        }
       }
-      case CloSXP clo -> replacePlaceHolder(selfRefEnv, clo.env(), name);
-      default -> {}
-    }
+      default -> v;
+    };
   }
 
   /**

From e0a56d1003832e362137063035177007b9fcd9b4 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 31 Jul 2024 16:52:40 +0200
Subject: [PATCH 25/80] Load base and create Package and Namespace envs

---
 .../java/org/prlprg/session/GNURSession.java  | 46 ++++++++++++-------
 .../org/prlprg/session/PackageDatabase.java   |  2 -
 .../org/prlprg/rsession/GNURSessionTest.java  |  4 +-
 3 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index 5237ba716..ff7264678 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -63,6 +63,8 @@ public NamespaceEnvSXP getNamespace(String name, String version) {
 public class GNURSession implements RSession {
   private URI cranMirror;
   private org.prlprg.RVersion RVersion;
+  private Path RDir;
+  private Path RLibraries;
 
   private @Nullable BaseEnvSXP baseEnv = null;
   private @Nullable NamespaceEnvSXP baseNamespace = null;
@@ -70,22 +72,24 @@ public class GNURSession implements RSession {
   private @Nullable Set<String> builtins = null;
   private @Nullable Set<String> specials = null;
   private @Nullable Set<String> builtinsInternal = null;
-  private @Nullable HashMap<String, NamespaceEnvSXP> namespaces = null;
+  private final HashMap<String, NamespaceEnvSXP> namespaces = new HashMap<>();
 
   // TODO: need the path to R *and* the path to the installed packages
-  public GNURSession(RVersion version, Path r_dir) {
+  public GNURSession(RVersion version, Path r_dir, Path r_libraries) {
     cranMirror = URI.create("https://cran.r-project.org");
     RVersion = version;
+    RDir = r_dir;
+    RLibraries = r_libraries;
   }
 
-  public GNURSession(RVersion version, Path r_dir, URI cranMirror) {
-    this(version, r_dir);
+  public GNURSession(RVersion version, Path r_dir, Path r_libraries, URI cranMirror) {
+    this(version, r_dir, r_libraries);
     this.cranMirror = cranMirror;
   }
 
   public void setCranMirror(URI uri) {}
 
-  // We should also handle installation of a package from a Github repo?
+  // We should also handle installation of a package from a GitHub repo?
   public void loadPackage(String name, String version) {
     // Check if package is installed and if not install it
 
@@ -94,8 +98,10 @@ public void loadPackage(String name, String version) {
   }
 
   public static HashMap<String, SEXP> readPackageDatabase(
-      RSession session, Path path, String packageName) throws IOException {
-    var db = new PackageDatabase(session, path, packageName);
+      RSession session, Path libPath, String packageName) throws IOException {
+    // the database is in the R subdirectory
+    var dbPath = libPath.resolve(packageName).resolve("R");
+    var db = new PackageDatabase(session, dbPath, packageName);
     return db.getBindings();
   }
 
@@ -134,7 +140,7 @@ public EnvSXP loadPackage(String name, String version, List<Messages.Function> f
   /**
    * Load the base environment and namespace.
    *
-   * <p>It requires a special treatment as the reader refers to base functions and so we need to
+   * <p>It requires a special treatment as the reader refers to base functions, and so we need to
    * carefully load symbols and then bind them.
    */
   public void loadBase(List<Messages.Function> functions) {
@@ -143,18 +149,22 @@ public void loadBase(List<Messages.Function> functions) {
   }
 
   /** Load base from the given installed R version */
-  public void loadBase(Path r_lib) throws IOException {
+  public void loadBase() {
     var session = new DummySession();
-    var objs = GNURSession.readPackageDatabase(session, r_lib, "base");
-    // TODO: write the right version of R (extract ot from the path?)
-    baseNamespace = new NamespaceEnvSXP("base", "4.3.2", this.globalEnv(), objs);
-    baseEnv = new BaseEnvSXP(objs);
+    var baseLibPath = RDir.resolve("library");
+    try {
+      var objs = GNURSession.readPackageDatabase(session, baseLibPath, "base");
+      baseNamespace = new NamespaceEnvSXP("base", RVersion.toString(), this.globalEnv(), objs);
+      baseEnv = new BaseEnvSXP(objs);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
   }
 
   @Override
   public NamespaceEnvSXP baseNamespace() {
     if (baseNamespace == null) {
-      // loadBase();
+      loadBase();
     }
     return baseNamespace;
   }
@@ -162,7 +172,7 @@ public NamespaceEnvSXP baseNamespace() {
   @Override
   public BaseEnvSXP baseEnv() {
     if (baseEnv == null) {
-      // loadBase();
+      loadBase();
     }
     return baseEnv;
   }
@@ -192,6 +202,10 @@ public boolean isBuiltinInternal(String name) {
 
   @Override
   public NamespaceEnvSXP getNamespace(String name, String version) {
-    return null;
+    var ns = namespaces.get(name);
+    if (ns == null) {
+      // TODO: check if the library is installed in the library path and load it
+    }
+    return ns;
   }
 }
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index b157c8f39..2d4998e53 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -302,8 +302,6 @@ public HashMap<String, SEXP> getBindings() throws IOException {
             .toList();
     LOGGER.info("Not Closures: " + notClos);
 
-    // TODO: filter out the env::n
-
     return objects;
   }
 }
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 879302c0d..67ce8eea7 100644
--- a/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -12,7 +12,7 @@ public class GNURSessionTest {
 
   @Test
   public void testReadPackageDatabase() throws IOException {
-    var session = new GNURSession(RVersion.LATEST_AWARE, null);
+    var session = new GNURSession(RVersion.LATEST_AWARE, null, null);
     var p = "~/R/x86_64-pc-linux-gnu-library/4.3/";
     p = p.replaceFirst("^~", System.getProperty("user.home"));
     var funs = GNURSession.readPackageDatabase(session, Path.of(p), "yaml");
@@ -22,7 +22,7 @@ public void testReadPackageDatabase() throws IOException {
 
   @Test
   public void testLoadBase() throws IOException {
-    var session = new GNURSession(RVersion.LATEST_AWARE, null);
+    var session = new GNURSession(RVersion.LATEST_AWARE, null, null);
     var p = "/usr/lib/R/library";
     session.loadBase(Path.of(p));
 

From 153df06fa0ced95cbde950606a174526c911345f Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 31 Jul 2024 18:16:07 +0200
Subject: [PATCH 26/80] Setup a package namespace before reading its database

---
 .../org/prlprg/server/CompileService.java     |  2 +-
 .../java/org/prlprg/session/GNURSession.java  | 26 ++++++++++++++-----
 .../org/prlprg/rsession/GNURSessionTest.java  | 17 +++++++-----
 3 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/src/main/java/org/prlprg/server/CompileService.java b/src/main/java/org/prlprg/server/CompileService.java
index 9d2fdeb16..4fc0eff47 100644
--- a/src/main/java/org/prlprg/server/CompileService.java
+++ b/src/main/java/org/prlprg/server/CompileService.java
@@ -110,7 +110,7 @@ public void init(
     logger.info("Received package hashes: " + packages);
 
     // TODO: Lookup to see if we have this version of R installed or not.
-    session = new GNURSession(convertVersion(RVersion), null);
+    session = new GNURSession(convertVersion(RVersion), null, null);
 
     // Look into our cache if we have the packages.
     // Request the packages for those we do not have hashes for.
diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index ff7264678..fa2d88d60 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -99,12 +99,25 @@ public void loadPackage(String name, String version) {
 
   public static HashMap<String, SEXP> readPackageDatabase(
       RSession session, Path libPath, String packageName) throws IOException {
-    // the database is in the R subdirectory
-    var dbPath = libPath.resolve(packageName).resolve("R");
-    var db = new PackageDatabase(session, dbPath, packageName);
+    var db = new PackageDatabase(session, libPath, packageName);
     return db.getBindings();
   }
 
+  /**
+   * Objects in a package database refer to their own namespace so we need to create it before
+   * reading.
+   *
+   * @param name
+   * @param version
+   */
+  public void prepareNamespace(String name, String version) {
+    var ns = namespaces.get(name + version);
+    if (ns == null) {
+      ns = new NamespaceEnvSXP(name, version, globalEnv, new HashMap<>());
+      namespaces.put(name + version, ns);
+    }
+  }
+
   /**
    * Makes it possible to load a package by providing its functions directly.
    *
@@ -154,8 +167,9 @@ public void loadBase() {
     var baseLibPath = RDir.resolve("library");
     try {
       var objs = GNURSession.readPackageDatabase(session, baseLibPath, "base");
-      baseNamespace = new NamespaceEnvSXP("base", RVersion.toString(), this.globalEnv(), objs);
       baseEnv = new BaseEnvSXP(objs);
+      globalEnv = new GlobalEnvSXP(baseEnv);
+      baseNamespace = new NamespaceEnvSXP("base", RVersion.toString(), globalEnv, objs);
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
@@ -180,7 +194,7 @@ public BaseEnvSXP baseEnv() {
   @Override
   public GlobalEnvSXP globalEnv() {
     if (globalEnv == null) {
-      globalEnv = new GlobalEnvSXP(baseEnv());
+      loadBase();
     }
     return globalEnv;
   }
@@ -202,7 +216,7 @@ public boolean isBuiltinInternal(String name) {
 
   @Override
   public NamespaceEnvSXP getNamespace(String name, String version) {
-    var ns = namespaces.get(name);
+    var ns = namespaces.get(name + version);
     if (ns == null) {
       // TODO: check if the library is installed in the library path and load it
     }
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 67ce8eea7..34778eef3 100644
--- a/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -12,19 +12,22 @@ public class GNURSessionTest {
 
   @Test
   public void testReadPackageDatabase() throws IOException {
-    var session = new GNURSession(RVersion.LATEST_AWARE, null, null);
-    var p = "~/R/x86_64-pc-linux-gnu-library/4.3/";
-    p = p.replaceFirst("^~", System.getProperty("user.home"));
-    var funs = GNURSession.readPackageDatabase(session, Path.of(p), "yaml");
+    var r_dir = Path.of("/usr/lib/R/");
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.3/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
+    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+
+    session.prepareNamespace("yaml", "2.3.8");
+    var funs = GNURSession.readPackageDatabase(session, Path.of(lib_dir), "yaml");
 
     Assertions.assertFalse(funs.isEmpty());
   }
 
   @Test
   public void testLoadBase() throws IOException {
-    var session = new GNURSession(RVersion.LATEST_AWARE, null, null);
-    var p = "/usr/lib/R/library";
-    session.loadBase(Path.of(p));
+    var p = Path.of("/usr/lib/R/");
+    var session = new GNURSession(RVersion.LATEST_AWARE, p, null);
+    session.loadBase();
 
     Assertions.assertFalse(session.baseNamespace().isEmpty());
   }

From d4efb4bf9ed979582249c5fb9275b44c90d30be1 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 1 Aug 2024 15:17:16 +0200
Subject: [PATCH 27/80] Load package with package name and package version

---
 .../java/org/prlprg/session/GNURSession.java  | 33 ++++++++++++++++---
 .../java/org/prlprg/sexp/AbstractEnvSXP.java  |  5 +++
 .../org/prlprg/rsession/GNURSessionTest.java  |  7 ++--
 3 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index fa2d88d60..a4c9b0698 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -92,12 +92,34 @@ public void setCranMirror(URI uri) {}
   // We should also handle installation of a package from a GitHub repo?
   public void loadPackage(String name, String version) {
     // Check if package is installed and if not install it
+    var pkgPath = RLibraries.resolve(name);
+    var pkgDir = pkgPath.toFile();
+    if (!pkgDir.exists() || !pkgDir.isDirectory()) {
+      // Check if the package exists in a repo
+      // Install the package
+      // TODO: call install.packages from GNU R
+      throw new UnsupportedOperationException("Package installation not implemented yet");
+    }
 
-    // Load index (name.rdx) and serialized objects (name.rdb)
-    // Or rather do lazy loading like R?
+    // Make sure base is loaded
+    if (baseNamespace == null) {
+      loadBase();
+    }
+
+    // Bootstrap the namespace
+    prepareNamespace(name, version);
+
+    // Load the package
+    try {
+      var bindings = readPackageDatabase(this, RLibraries, name);
+      var ns = namespaces.get(name + version);
+      ns.setBindings(bindings);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
   }
 
-  public static HashMap<String, SEXP> readPackageDatabase(
+  private static HashMap<String, SEXP> readPackageDatabase(
       RSession session, Path libPath, String packageName) throws IOException {
     var db = new PackageDatabase(session, libPath, packageName);
     return db.getBindings();
@@ -110,8 +132,11 @@ public static HashMap<String, SEXP> readPackageDatabase(
    * @param name
    * @param version
    */
-  public void prepareNamespace(String name, String version) {
+  private void prepareNamespace(String name, String version) {
     var ns = namespaces.get(name + version);
+    if (globalEnv == null) {
+      loadBase();
+    }
     if (ns == null) {
       ns = new NamespaceEnvSXP(name, version, globalEnv, new HashMap<>());
       namespaces.put(name + version, ns);
diff --git a/src/main/java/org/prlprg/sexp/AbstractEnvSXP.java b/src/main/java/org/prlprg/sexp/AbstractEnvSXP.java
index 4821a1d8d..b22cb444d 100644
--- a/src/main/java/org/prlprg/sexp/AbstractEnvSXP.java
+++ b/src/main/java/org/prlprg/sexp/AbstractEnvSXP.java
@@ -51,6 +51,11 @@ public void set(String name, SEXP value) {
     bindings.put(name, value);
   }
 
+  public void setBindings(Map<String, SEXP> bindings) {
+    this.bindings.clear();
+    this.bindings.putAll(bindings);
+  }
+
   @Override
   public String toString() {
     return Printer.toString(this);
diff --git a/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 34778eef3..f17714cf0 100644
--- a/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -17,10 +17,11 @@ public void testReadPackageDatabase() throws IOException {
     lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
-    session.prepareNamespace("yaml", "2.3.8");
-    var funs = GNURSession.readPackageDatabase(session, Path.of(lib_dir), "yaml");
+    session.loadPackage("yaml", "2.3.8");
 
-    Assertions.assertFalse(funs.isEmpty());
+    var ns = session.getNamespace("yaml", "2.3.8");
+
+    Assertions.assertFalse(ns.bindings().isEmpty());
   }
 
   @Test

From 562a519599478b46e687f0eb740297f31ba92f12 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 2 Aug 2024 15:43:44 +0200
Subject: [PATCH 28/80] Compile route test now works

---
 .../java/org/prlprg/server/CompileService.java     |  9 +++++++--
 src/test/java/org/prlprg/server/ServerTests.java   | 14 ++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/prlprg/server/CompileService.java b/src/main/java/org/prlprg/server/CompileService.java
index 4fc0eff47..101b7b6f8 100644
--- a/src/main/java/org/prlprg/server/CompileService.java
+++ b/src/main/java/org/prlprg/server/CompileService.java
@@ -4,6 +4,7 @@
 import io.grpc.Status;
 import io.grpc.stub.StreamObserver;
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
@@ -110,9 +111,13 @@ public void init(
     logger.info("Received package hashes: " + packages);
 
     // TODO: Lookup to see if we have this version of R installed or not.
-    session = new GNURSession(convertVersion(RVersion), null, null);
+    // Hardcoded so far:
+    var r_dir = Path.of("/usr/lib/R/");
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.3/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
+    session = new GNURSession(convertVersion(RVersion), r_dir, Path.of(lib_dir));
 
-    // Look into our cache if we have the packages.
+    // TODO: Look into our cache if we have the packages.
     // Request the packages for those we do not have hashes for.
 
     responseObserver.onNext(Messages.InitResponse.newBuilder().build());
diff --git a/src/test/java/org/prlprg/server/ServerTests.java b/src/test/java/org/prlprg/server/ServerTests.java
index 1d0854239..801f36801 100644
--- a/src/test/java/org/prlprg/server/ServerTests.java
+++ b/src/test/java/org/prlprg/server/ServerTests.java
@@ -53,6 +53,20 @@ void testCompile(Resources resources) throws IOException {
     assert channel != null;
     resources.register(channel, Duration.ofSeconds(3));
 
+    // Init compile server
+    var initRequest =
+        Messages.InitRequest.newBuilder()
+            .setRVersion(Messages.Version.newBuilder().setMajor(4).setMinor(3).setPatch(2).build())
+            .setRshVersion(Messages.Version.newBuilder().build())
+            .setPlatform("amd64")
+            .build();
+    assert blockingStub != null;
+    assertDoesNotThrow(
+        () -> {
+          Messages.InitResponse initResponse = blockingStub.init(initRequest);
+        });
+
+    // Compile identify function
     var function =
         SEXPs.closure(
             SEXPs.list(new TaggedElem("x", SEXPs.symbol("x"))), SEXPs.symbol("x"), SEXPs.EMPTY_ENV);

From 42e33f2ab954590ad457663df5a74336a15bd4cd Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 2 Aug 2024 17:05:38 +0200
Subject: [PATCH 29/80] Add back Filip's rsh compiler (service package)

---
 .idea/misc.xml                                |  2 +-
 .../prlprg/service/CCCompilationBuilder.java  | 81 ++++++++++++++++
 .../org/prlprg/service/CompiledFunction.java  |  6 ++
 .../java/org/prlprg/service/JITService.java   | 51 ++++++++++
 .../java/org/prlprg/service/RshCompiler.java  | 97 +++++++++++++++++++
 src/test/java/org/prlprg/RClosureTests.java   | 94 +++++++++---------
 .../org/prlprg/bc2c/BC2CCompilerTest.java     | 14 +--
 7 files changed, 287 insertions(+), 58 deletions(-)
 create mode 100644 src/main/java/org/prlprg/service/CCCompilationBuilder.java
 create mode 100644 src/main/java/org/prlprg/service/CompiledFunction.java
 create mode 100644 src/main/java/org/prlprg/service/JITService.java
 create mode 100644 src/main/java/org/prlprg/service/RshCompiler.java

diff --git a/.idea/misc.xml b/.idea/misc.xml
index 7968620f6..2b4f7d197 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -64,7 +64,7 @@
       </value>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="22" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_22" default="true" project-jdk-name="22 (2)" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>
\ No newline at end of file
diff --git a/src/main/java/org/prlprg/service/CCCompilationBuilder.java b/src/main/java/org/prlprg/service/CCCompilationBuilder.java
new file mode 100644
index 000000000..2586fb544
--- /dev/null
+++ b/src/main/java/org/prlprg/service/CCCompilationBuilder.java
@@ -0,0 +1,81 @@
+package org.prlprg.service;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Logger;
+
+// TODO: consider in-memory filesystem
+public class CCCompilationBuilder {
+
+  // TODO: configurable from environment variable
+  private static final String DEFAULT_COMPILER = "gcc";
+
+  private final File input;
+  private final File output;
+  private final List<String> flags = new ArrayList<>();
+  private String compiler = DEFAULT_COMPILER;
+  private File workingDirectory;
+
+  public CCCompilationBuilder(File input, File output) {
+    this.input = input;
+    this.output = output;
+  }
+
+  public CCCompilationBuilder flag(String flag) {
+    flags.add(flag);
+    return this;
+  }
+
+  // TODO: return something with warnings, ...
+  public void compile() throws IOException, InterruptedException {
+    var logger = Logger.getLogger(CCCompilationBuilder.class.getName());
+
+    var builder = new ProcessBuilder();
+    builder.redirectErrorStream(true);
+    builder.directory(workingDirectory);
+    builder.command(compiler, "-o", output.getPath(), input.getPath());
+    builder.command().addAll(flags);
+
+    logger.fine("Running command: " + String.join(" ", builder.command()));
+
+    Process process = builder.start();
+
+    // Capture the output and error streams
+    StringBuilder output = new StringBuilder();
+    try (BufferedReader reader =
+        new BufferedReader(new InputStreamReader(process.getInputStream()))) {
+      String line;
+      while ((line = reader.readLine()) != null) {
+        output.append(line).append(System.lineSeparator());
+      }
+    }
+
+    int exitCode = process.waitFor();
+
+    if (exitCode != 0) {
+      throw new RuntimeException(
+          "Compilation failed with exit code "
+              + exitCode
+              + ":\n"
+              + String.join(" ", builder.command())
+              + "\n"
+              + output);
+    }
+
+    if (!output.isEmpty()) {
+      logger.warning("Compilation warnings:\n" + output);
+    }
+  }
+
+  public CCCompilationBuilder flags(Collection<String> flags) {
+    this.flags.addAll(flags);
+    return this;
+  }
+
+  public CCCompilationBuilder workingDirectory(File directory) {
+    this.workingDirectory = directory;
+    return this;
+  }
+}
diff --git a/src/main/java/org/prlprg/service/CompiledFunction.java b/src/main/java/org/prlprg/service/CompiledFunction.java
new file mode 100644
index 000000000..7b566ff48
--- /dev/null
+++ b/src/main/java/org/prlprg/service/CompiledFunction.java
@@ -0,0 +1,6 @@
+package org.prlprg.service;
+
+import java.util.List;
+import org.prlprg.sexp.SEXP;
+
+public record CompiledFunction(byte[] code, List<SEXP> constantPool) {}
diff --git a/src/main/java/org/prlprg/service/JITService.java b/src/main/java/org/prlprg/service/JITService.java
new file mode 100644
index 000000000..64616639e
--- /dev/null
+++ b/src/main/java/org/prlprg/service/JITService.java
@@ -0,0 +1,51 @@
+package org.prlprg.service;
+
+import com.google.common.io.Files;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.logging.Logger;
+import org.prlprg.bc.BCCompiler;
+import org.prlprg.bc2c.BC2CCompiler;
+import org.prlprg.session.RSession;
+import org.prlprg.sexp.CloSXP;
+
+public class JITService {
+  private final RSession rsession;
+
+  private static final Logger logger = Logger.getLogger(JITService.class.getName());
+
+  public JITService(RSession rsession) {
+    this.rsession = rsession;
+  }
+
+  public CompiledFunction execute(String name, CloSXP closure, int ccOptimization)
+      throws IOException, InterruptedException {
+    logger.fine("Compiling closure: " + name + "\n" + closure + "\n");
+
+    var bcCompiler = new BCCompiler(closure, rsession);
+    var bc = bcCompiler.compile().get();
+    var bc2cCompiler = new BC2CCompiler(name, bc);
+    var cfile = bc2cCompiler.compile();
+    // var input = new File("/tmp/jit.c");
+    var input = File.createTempFile("cfile", ".c");
+    var f = Files.newWriter(input, Charset.defaultCharset());
+    cfile.writeTo(f);
+    // var output = new File("/tmp/jit.o");
+    var output = File.createTempFile("ofile", ".o");
+
+    RshCompiler.getInstance().compile(input, output, ccOptimization);
+
+    var res = Files.asByteSource(output).read();
+
+    //    if (!input.delete()) {
+    //      throw new IOException("Unable to delete file" + input);
+    //    }
+
+    //    if (!output.delete()) {
+    //      throw new IOException("Unable to delete file" + input);
+    //    }
+
+    return new CompiledFunction(res, bc2cCompiler.constants());
+  }
+}
diff --git a/src/main/java/org/prlprg/service/RshCompiler.java b/src/main/java/org/prlprg/service/RshCompiler.java
new file mode 100644
index 000000000..30ed0027d
--- /dev/null
+++ b/src/main/java/org/prlprg/service/RshCompiler.java
@@ -0,0 +1,97 @@
+package org.prlprg.service;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Logger;
+
+public class RshCompiler {
+  private static final Logger logger = Logger.getLogger(RshCompiler.class.getName());
+
+  // TODO: make it configurable
+  private static final String INCLUDE_PATH = "backend/include";
+
+  // TODO: which ones are needed? Can we bootstrap it from R?
+  private static final List<String> COMPILER_FLAGS =
+      List.of(
+          "-DNDEBUG",
+          "-I.",
+          "-I" + INCLUDE_PATH,
+          "-fpic",
+          "-march=x86-64",
+          "-mtune=generic",
+          "-pipe",
+          "-fno-plt",
+          "-fexceptions",
+          "-fstack-clash-protection",
+          "-fcf-protection",
+          "-flto=auto",
+          "-ffat-lto-objects",
+          "-Wformat",
+          "-Werror=format-security",
+          "-Wall",
+          "-Wno-unused-but-set-variable",
+          "-Wno-comment",
+          "-pedantic",
+          "-O3",
+          // FIXME: the debugging should be parameterize
+          "-ggdb",
+          "-g3");
+
+  private static RshCompiler instance;
+
+  public static RshCompiler getInstance() {
+    if (instance == null) {
+      try {
+        instance = new RshCompiler();
+        instance.initialize();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    }
+
+    return instance;
+  }
+
+  private void initialize() throws IOException, InterruptedException {
+    // TODO: make it constants
+    var input = new File("Rsh.h");
+    var output = new File("Rsh.h.gch");
+    new CCCompilationBuilder(input, output)
+        .workingDirectory(new File(INCLUDE_PATH))
+        .flags(COMPILER_FLAGS)
+        .compile();
+  }
+
+  public void compile(File input, File output, int ccOptimization)
+      throws IOException, InterruptedException {
+    logger.fine("Compiling input: " + input + ", output: " + output);
+
+    var builder =
+        new CCCompilationBuilder(input, output)
+            .flags(COMPILER_FLAGS)
+            .flag("-c")
+            .flag("-O" + ccOptimization);
+    var time = System.currentTimeMillis();
+    builder.compile();
+    time = System.currentTimeMillis() - time;
+
+    var size = output.length();
+
+    logger.fine("Finished compilation in %d ms (size: %d)\n".formatted(time, size));
+  }
+
+  // FIXME: remove the duplication
+  public void compileShared(File input, File output) throws IOException, InterruptedException {
+    logger.fine("Compiling input: " + input + ", output: " + output);
+
+    var builder = new CCCompilationBuilder(input, output).flags(COMPILER_FLAGS).flag("-shared");
+    var time = System.currentTimeMillis();
+    builder.compile();
+    time = System.currentTimeMillis() - time;
+
+    var size = output.length();
+
+    logger.fine("Finished compilation in %d ms (size: %d)\n".formatted(time, size));
+  }
+}
diff --git a/src/test/java/org/prlprg/RClosureTests.java b/src/test/java/org/prlprg/RClosureTests.java
index 550379c40..1c614ace6 100644
--- a/src/test/java/org/prlprg/RClosureTests.java
+++ b/src/test/java/org/prlprg/RClosureTests.java
@@ -19,7 +19,7 @@
  */
 public abstract class RClosureTests extends AbstractGNURBasedTest {
   @Test
-  public void testEmptyList() {
+  public void testEmptyList() throws Exception {
     testClosure(
         """
         function ()
@@ -30,7 +30,7 @@ public void testEmptyList() {
   }
 
   @Test
-  public void testEmptyBlock() {
+  public void testEmptyBlock() throws Exception {
     testClosure(
         """
         function() {}
@@ -38,7 +38,7 @@ public void testEmptyBlock() {
   }
 
   @Test
-  public void testSingleExpressionBlock() {
+  public void testSingleExpressionBlock() throws Exception {
     testClosure(
         """
         function() { 1 }
@@ -46,7 +46,7 @@ public void testSingleExpressionBlock() {
   }
 
   @Test
-  public void testMultipleExpressionBlock() {
+  public void testMultipleExpressionBlock() throws Exception {
     testClosure(
         """
         function() { 1; 2 }
@@ -54,7 +54,7 @@ public void testMultipleExpressionBlock() {
   }
 
   @Test
-  public void testIf() {
+  public void testIf() throws Exception {
     testClosure(
         """
         function(x) if (x) 1
@@ -62,7 +62,7 @@ public void testIf() {
   }
 
   @Test
-  public void testIfElse() {
+  public void testIfElse() throws Exception {
     testClosure(
         """
         function(x) if (x) 1 else 2
@@ -70,7 +70,7 @@ public void testIfElse() {
   }
 
   @Test
-  public void testFunctionInlining() {
+  public void testFunctionInlining() throws Exception {
     testClosure(
         """
         function(x) function(y) 1
@@ -78,7 +78,7 @@ public void testFunctionInlining() {
   }
 
   @Test
-  public void testFunctionLeftParenInlining() {
+  public void testFunctionLeftParenInlining() throws Exception {
     testClosure(
         """
         function(x) (x)
@@ -91,7 +91,7 @@ public void testFunctionLeftParenInlining() {
   }
 
   @Test
-  public void builtinsInlining() {
+  public void builtinsInlining() throws Exception {
     // expecting a guard
     testClosure(
         """
@@ -115,7 +115,7 @@ public void builtinsInlining() {
   }
 
   @Test
-  public void specialsInlining() {
+  public void specialsInlining() throws Exception {
     testClosure(
         """
       function() rep(1, 10)
@@ -123,7 +123,7 @@ public void specialsInlining() {
   }
 
   @Test
-  public void inlineLocal() {
+  public void inlineLocal() throws Exception {
     testClosure(
         """
       function(x) local(x)
@@ -131,7 +131,7 @@ public void inlineLocal() {
   }
 
   @Test
-  public void inlineReturn() {
+  public void inlineReturn() throws Exception {
     testClosure(
         """
       function(x) return(x)
@@ -139,7 +139,7 @@ public void inlineReturn() {
   }
 
   @Test
-  public void inlineBuiltinsInternal() {
+  public void inlineBuiltinsInternal() throws Exception {
     testClosure(
         """
       function(x) .Internal(inspect(x))
@@ -152,7 +152,7 @@ public void inlineBuiltinsInternal() {
   }
 
   @Test
-  public void inlineLogicalAnd() {
+  public void inlineLogicalAnd() throws Exception {
     testClosure(
         """
       function(x, y) x && y
@@ -170,7 +170,7 @@ public void inlineLogicalAnd() {
   }
 
   @Test
-  public void inlineLogicalOr() {
+  public void inlineLogicalOr() throws Exception {
     testClosure(
         """
       function(x, y) x || y
@@ -188,7 +188,7 @@ public void inlineLogicalOr() {
   }
 
   @Test
-  public void inlineLogicalAndOr() {
+  public void inlineLogicalAndOr() throws Exception {
     testClosure(
         """
       function(x, y) x && y || y
@@ -201,7 +201,7 @@ public void inlineLogicalAndOr() {
   }
 
   @Test
-  public void inlineRepeat() {
+  public void inlineRepeat() throws Exception {
     testClosure(
         """
       function(x) repeat(x)
@@ -224,7 +224,7 @@ public void inlineRepeat() {
   }
 
   @Test
-  public void inlineWhile() {
+  public void inlineWhile() throws Exception {
     testClosure(
         """
       function(x) while(x) 1
@@ -242,7 +242,7 @@ public void inlineWhile() {
   }
 
   @Test
-  public void inlineFor() {
+  public void inlineFor() throws Exception {
     testClosure(
         """
       function(x) for (i in x) 1
@@ -255,7 +255,7 @@ public void inlineFor() {
   }
 
   @Test
-  public void inlineArithmetics() {
+  public void inlineArithmetics() throws Exception {
     testClosure(
         """
       function(x, y) x + y
@@ -289,7 +289,7 @@ public void inlineArithmetics() {
   }
 
   @Test
-  public void inlineMath1() {
+  public void inlineMath1() throws Exception {
     testClosure(
         """
       function(x) {
@@ -306,7 +306,7 @@ public void inlineMath1() {
   }
 
   @Test
-  public void inlineLogical() {
+  public void inlineLogical() throws Exception {
     testClosure(
         """
       function(x, y) {
@@ -318,7 +318,7 @@ public void inlineLogical() {
   }
 
   @Test
-  public void inlineDollar() {
+  public void inlineDollar() throws Exception {
     testClosure(
         """
       # xs <- list(a=1, b=list(c=2))
@@ -333,7 +333,7 @@ public void inlineDollar() {
   }
 
   @Test
-  public void inlineIsXYZ() {
+  public void inlineIsXYZ() throws Exception {
     testClosure(
         """
       function(x) {
@@ -353,7 +353,7 @@ public void inlineIsXYZ() {
   }
 
   @Test
-  public void inlineDotCall() {
+  public void inlineDotCall() throws Exception {
     testClosure(
         """
       function(x) {
@@ -364,7 +364,7 @@ public void inlineDotCall() {
   }
 
   @Test
-  public void inlineIntGeneratingSequences() {
+  public void inlineIntGeneratingSequences() throws Exception {
     testClosure(
         """
       function(x, xs) {
@@ -374,7 +374,7 @@ public void inlineIntGeneratingSequences() {
   }
 
   @Test
-  public void multiColon() {
+  public void multiColon() throws Exception {
     testClosure(
         """
       function() {
@@ -384,7 +384,7 @@ public void multiColon() {
   }
 
   @Test
-  public void inlineSwitch() {
+  public void inlineSwitch() throws Exception {
     testClosure(
         """
       function(x) {
@@ -396,7 +396,7 @@ public void inlineSwitch() {
   }
 
   @Test
-  public void inlineAssign1() {
+  public void inlineAssign1() throws Exception {
     testClosure(
         """
       function() {
@@ -422,7 +422,7 @@ public void inlineAssign1() {
   }
 
   @Test
-  public void inlineAssign2() {
+  public void inlineAssign2() throws Exception {
     testClosure(
         """
       function() {
@@ -439,7 +439,7 @@ public void inlineAssign2() {
   }
 
   @Test
-  public void inlineAssign3() {
+  public void inlineAssign3() throws Exception {
     testClosure(
         """
       function() {
@@ -449,7 +449,7 @@ public void inlineAssign3() {
   }
 
   @Test
-  public void inlineDollarAssign() {
+  public void inlineDollarAssign() throws Exception {
     testClosure(
         """
       function() {
@@ -461,7 +461,7 @@ public void inlineDollarAssign() {
   }
 
   @Test
-  public void inlineSquareAssign1() {
+  public void inlineSquareAssign1() throws Exception {
     testClosure(
         """
       function() {
@@ -472,7 +472,7 @@ public void inlineSquareAssign1() {
   }
 
   @Test
-  public void inlineSquareAssign2() {
+  public void inlineSquareAssign2() throws Exception {
     testClosure(
         """
       function() {
@@ -483,7 +483,7 @@ public void inlineSquareAssign2() {
   }
 
   @Test
-  public void inlineSquareAssign3() {
+  public void inlineSquareAssign3() throws Exception {
     testClosure(
         """
       function() {
@@ -494,7 +494,7 @@ public void inlineSquareAssign3() {
   }
 
   @Test
-  public void inlineSquareAssign4() {
+  public void inlineSquareAssign4() throws Exception {
     testClosure(
         """
       function() {
@@ -504,7 +504,7 @@ public void inlineSquareAssign4() {
   }
 
   @Test
-  public void inlineSquareSubset1() {
+  public void inlineSquareSubset1() throws Exception {
     testClosure(
         """
       function() {
@@ -515,7 +515,7 @@ public void inlineSquareSubset1() {
   }
 
   @Test
-  public void inlineSquareSubset2() {
+  public void inlineSquareSubset2() throws Exception {
     testClosure(
         """
       function() {
@@ -526,7 +526,7 @@ public void inlineSquareSubset2() {
   }
 
   @Test
-  public void inlineSquareSubset3() {
+  public void inlineSquareSubset3() throws Exception {
     testClosure(
         """
       function() {
@@ -537,7 +537,7 @@ public void inlineSquareSubset3() {
   }
 
   @Test
-  public void inlineSquareSubset4() {
+  public void inlineSquareSubset4() throws Exception {
     testClosure(
         """
       function() {
@@ -548,7 +548,7 @@ public void inlineSquareSubset4() {
   }
 
   @Test
-  public void inlineSlotAssign() {
+  public void inlineSlotAssign() throws Exception {
     testClosure(
         """
       function() {
@@ -560,7 +560,7 @@ public void inlineSlotAssign() {
   }
 
   @Test
-  public void inlineIdentical() {
+  public void inlineIdentical() throws Exception {
     testClosure(
         """
       function(x) {
@@ -570,7 +570,7 @@ public void inlineIdentical() {
   }
 
   @Test
-  public void constantFoldingC() {
+  public void constantFoldingC() throws Exception {
     // no constant folding - c is resolved from baseenv()
     testClosure(
         """
@@ -590,7 +590,7 @@ public void constantFoldingC() {
   }
 
   @Test
-  public void constantFoldMul() {
+  public void constantFoldMul() throws Exception {
     testClosure(
         """
       function() {
@@ -601,7 +601,7 @@ public void constantFoldMul() {
 
   @ParameterizedTest
   @MethodSource("stdlibFunctionsList")
-  public void stdlibFunctions(String name) {
+  public void stdlibFunctions(String name) throws Exception {
     testClosure(name);
   }
 
@@ -640,9 +640,9 @@ protected double stdlibTestsRatio() {
     return 1;
   }
 
-  protected void testClosure(String closure) {
+  protected void testClosure(String closure) throws Exception {
     testClosure(closure, BCCompiler.DEFAULT_OPTIMIZATION_LEVEL);
   }
 
-  protected abstract void testClosure(String closure, int optimizationLevel);
+  protected abstract void testClosure(String closure, int optimizationLevel) throws Exception;
 }
diff --git a/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java b/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
index 3cae0f927..81eabdb36 100644
--- a/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
+++ b/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
@@ -2,17 +2,9 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
-import java.io.File;
-import java.util.Objects;
-import java.util.function.Consumer;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInfo;
-import org.prlprg.AbstractGNURBasedTest;
-import org.prlprg.bc.BCCompiler;
-import org.prlprg.rds.RDSWriter;
 import org.prlprg.sexp.*;
-import org.prlprg.util.Files;
 
+/*
 // FIXME: move to the compiler
 class CCompilationException extends Exception {
   private final String command;
@@ -204,7 +196,7 @@ <T extends SEXP> void compileAndCall(String code, String env, Consumer<T> valida
       var cCode = bc2c.compile();
       var cConsts = bc2c.constants();
 
-      RDSWriter.writeFile(rsession, cpFile, SEXPs.vec(cConsts));
+      RDSWriter.writeFile(cpFile, SEXPs.vec(cConsts));
 
       Files.writeString(cFile.toPath(), cCode.toString());
 
@@ -241,3 +233,5 @@ <T extends SEXP> void compileAndCall(String code, String env, Consumer<T> valida
     }
   }
 }
+
+*/

From 940436078c2477aa3fcbd9b4a9137987169d6f98 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 6 Aug 2024 15:34:18 +0200
Subject: [PATCH 30/80] Remove the persist env from the list of bindings of a
 package

---
 src/main/java/org/prlprg/session/GNURSession.java     | 5 ++++-
 src/main/java/org/prlprg/session/PackageDatabase.java | 3 +++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/prlprg/session/GNURSession.java b/src/main/java/org/prlprg/session/GNURSession.java
index a4c9b0698..d5ddf436a 100644
--- a/src/main/java/org/prlprg/session/GNURSession.java
+++ b/src/main/java/org/prlprg/session/GNURSession.java
@@ -243,7 +243,10 @@ public boolean isBuiltinInternal(String name) {
   public NamespaceEnvSXP getNamespace(String name, String version) {
     var ns = namespaces.get(name + version);
     if (ns == null) {
-      // TODO: check if the library is installed in the library path and load it
+      // That could also fail!
+      // In that case, ask the client to send the package content
+      loadPackage(name, version);
+      ns = namespaces.get(name + version);
     }
     return ns;
   }
diff --git a/src/main/java/org/prlprg/session/PackageDatabase.java b/src/main/java/org/prlprg/session/PackageDatabase.java
index 2d4998e53..71e2da3b0 100644
--- a/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -302,6 +302,9 @@ public HashMap<String, SEXP> getBindings() throws IOException {
             .toList();
     LOGGER.info("Not Closures: " + notClos);
 
+    // Remove the persist environments
+    objects.keySet().removeAll(tmpEnvs.keySet());
+
     return objects;
   }
 }

From fc4ca5665f58d578a8a9d8f68bd4a7e88b7cd424 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 7 Aug 2024 16:03:32 +0200
Subject: [PATCH 31/80] Fix paths due to the new monorepo structure

---
 .idea/.gitignore                        |   8 -
 .idea/code.iml                          |   9 -
 .idea/codeStyles/Project.xml            | 290 ------------------------
 .idea/codeStyles/codeStyleConfig.xml    |   5 -
 .idea/compiler.xml                      |  15 --
 .idea/encodings.xml                     |   7 -
 .idea/google-java-format.xml            |   6 -
 .idea/jarRepositories.xml               |  20 --
 .idea/misc.xml                          |  70 ------
 .idea/vcs.xml                           |   6 -
 .jqwik-database                         | Bin 4 -> 0 bytes
 .tool-versions => server/.tool-versions |   0
 server/Makefile                         |   2 +-
 13 files changed, 1 insertion(+), 437 deletions(-)
 delete mode 100644 .idea/.gitignore
 delete mode 100644 .idea/code.iml
 delete mode 100644 .idea/codeStyles/Project.xml
 delete mode 100644 .idea/codeStyles/codeStyleConfig.xml
 delete mode 100644 .idea/compiler.xml
 delete mode 100644 .idea/encodings.xml
 delete mode 100644 .idea/google-java-format.xml
 delete mode 100644 .idea/jarRepositories.xml
 delete mode 100644 .idea/misc.xml
 delete mode 100644 .idea/vcs.xml
 delete mode 100644 .jqwik-database
 rename .tool-versions => server/.tool-versions (100%)

diff --git a/.idea/.gitignore b/.idea/.gitignore
deleted file mode 100644
index 13566b81b..000000000
--- a/.idea/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
diff --git a/.idea/code.iml b/.idea/code.iml
deleted file mode 100644
index d6ebd4805..000000000
--- a/.idea/code.iml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
deleted file mode 100644
index edd5ef344..000000000
--- a/.idea/codeStyles/Project.xml
+++ /dev/null
@@ -1,290 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <ScalaCodeStyleSettings>
-      <option name="MULTILINE_STRING_CLOSING_QUOTES_ON_NEW_LINE" value="true" />
-    </ScalaCodeStyleSettings>
-    <codeStyleSettings language="JAVA">
-      <arrangement>
-        <groups>
-          <group>
-            <type>GETTERS_AND_SETTERS</type>
-            <order>KEEP</order>
-          </group>
-          <group>
-            <type>OVERRIDDEN_METHODS</type>
-            <order>KEEP</order>
-          </group>
-        </groups>
-        <rules>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PUBLIC>true</PUBLIC>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PROTECTED>true</PROTECTED>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PRIVATE>true</PRIVATE>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PUBLIC>true</PUBLIC>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PROTECTED>true</PROTECTED>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PRIVATE>true</PRIVATE>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <INITIALIZER_BLOCK>true</INITIALIZER_BLOCK>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PUBLIC>true</PUBLIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PROTECTED>true</PROTECTED>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <FINAL>true</FINAL>
-                  <PRIVATE>true</PRIVATE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PUBLIC>true</PUBLIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PROTECTED>true</PROTECTED>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <FIELD>true</FIELD>
-                  <PRIVATE>true</PRIVATE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <FIELD>true</FIELD>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <INITIALIZER_BLOCK>true</INITIALIZER_BLOCK>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <CONSTRUCTOR>true</CONSTRUCTOR>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <METHOD>true</METHOD>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-              <order>BY_NAME</order>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <METHOD>true</METHOD>
-                  <PRIVATE>true</PRIVATE>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <METHOD>true</METHOD>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <ENUM>true</ENUM>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <INTERFACE>true</INTERFACE>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <CLASS>true</CLASS>
-                  <STATIC>true</STATIC>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <CLASS>true</CLASS>
-              </match>
-            </rule>
-          </section>
-        </rules>
-      </arrangement>
-    </codeStyleSettings>
-  </code_scheme>
-</component>
\ No newline at end of file
diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
deleted file mode 100644
index b9d18bf59..000000000
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="GoogleStyle" />
-  </state>
-</component>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
deleted file mode 100644
index 05797b2b0..000000000
--- a/.idea/compiler.xml
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <annotationProcessing>
-      <profile name="Maven default annotation processors profile" enabled="true">
-        <sourceOutputDir name="target/generated-sources/annotations" />
-        <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
-        <outputRelativeToContentRoot value="true" />
-      </profile>
-    </annotationProcessing>
-    <bytecodeTargetLevel>
-      <module name="r-compile-server" target="22" />
-    </bytecodeTargetLevel>
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/encodings.xml b/.idea/encodings.xml
deleted file mode 100644
index 2c23a594f..000000000
--- a/.idea/encodings.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Encoding">
-    <file url="file://$PROJECT_DIR$/server/src/main/java" charset="UTF-8" />
-    <file url="file://$PROJECT_DIR$/server/src/main/resources" charset="UTF-8" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/google-java-format.xml b/.idea/google-java-format.xml
deleted file mode 100644
index 8b57f4527..000000000
--- a/.idea/google-java-format.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GoogleJavaFormatSettings">
-    <option name="enabled" value="true" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
deleted file mode 100644
index 712ab9d98..000000000
--- a/.idea/jarRepositories.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RemoteRepositoriesConfiguration">
-    <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Central Repository" />
-      <option name="url" value="https://repo.maven.apache.org/maven2" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Maven Central repository" />
-      <option name="url" value="https://repo1.maven.org/maven2" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="jboss.community" />
-      <option name="name" value="JBoss Community repository" />
-      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
-    </remote-repository>
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
deleted file mode 100644
index 2b4f7d197..000000000
--- a/.idea/misc.xml
+++ /dev/null
@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EntryPointsManager">
-    <list size="4">
-      <item index="0" class="java.lang.String" itemvalue="net.jqwik.api.Provide" />
-      <item index="1" class="java.lang.String" itemvalue="net.jqwik.api.lifecycle.BeforeContainer" />
-      <item index="2" class="java.lang.String" itemvalue="org.prlprg.parseprint.ParseMethod" />
-      <item index="3" class="java.lang.String" itemvalue="org.prlprg.parseprint.PrintMethod" />
-    </list>
-  </component>
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="MavenProjectsManager">
-    <option name="originalFiles">
-      <list>
-        <option value="$PROJECT_DIR$/pom.xml" />
-      </list>
-    </option>
-  </component>
-  <component name="NullableNotNullManager">
-    <option name="myDefaultNullable" value="javax.annotation.Nullable" />
-    <option name="myDefaultNotNull" value="org.jetbrains.annotations.NotNull" />
-    <option name="myNullables">
-      <value>
-        <list size="16">
-          <item index="0" class="java.lang.String" itemvalue="org.jspecify.annotations.Nullable" />
-          <item index="1" class="java.lang.String" itemvalue="com.android.annotations.Nullable" />
-          <item index="2" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.Nullable" />
-          <item index="3" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNullable" />
-          <item index="4" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableDecl" />
-          <item index="5" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
-          <item index="6" class="java.lang.String" itemvalue="androidx.annotation.Nullable" />
-          <item index="7" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.Nullable" />
-          <item index="8" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.Nullable" />
-          <item index="9" class="java.lang.String" itemvalue="android.support.annotation.Nullable" />
-          <item index="10" class="java.lang.String" itemvalue="jakarta.annotation.Nullable" />
-          <item index="11" class="java.lang.String" itemvalue="javax.annotation.CheckForNull" />
-          <item index="12" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
-          <item index="13" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.Nullable" />
-          <item index="14" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableType" />
-          <item index="15" class="java.lang.String" itemvalue="io.reactivex.annotations.Nullable" />
-        </list>
-      </value>
-    </option>
-    <option name="myNotNulls">
-      <value>
-        <list size="16">
-          <item index="0" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNonNull" />
-          <item index="1" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.NonNull" />
-          <item index="2" class="java.lang.String" itemvalue="org.jspecify.annotations.NonNull" />
-          <item index="3" class="java.lang.String" itemvalue="jakarta.annotation.Nonnull" />
-          <item index="4" class="java.lang.String" itemvalue="io.reactivex.annotations.NonNull" />
-          <item index="5" class="java.lang.String" itemvalue="androidx.annotation.NonNull" />
-          <item index="6" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullType" />
-          <item index="7" class="java.lang.String" itemvalue="lombok.NonNull" />
-          <item index="8" class="java.lang.String" itemvalue="android.support.annotation.NonNull" />
-          <item index="9" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.NonNull" />
-          <item index="10" class="java.lang.String" itemvalue="com.android.annotations.NonNull" />
-          <item index="11" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.NonNull" />
-          <item index="12" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullDecl" />
-          <item index="13" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
-          <item index="14" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
-          <item index="15" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.NonNull" />
-        </list>
-      </value>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_22" default="true" project-jdk-name="22 (2)" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
deleted file mode 100644
index 35eb1ddfb..000000000
--- a/.idea/vcs.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.jqwik-database b/.jqwik-database
deleted file mode 100644
index 711006c3d3b5c6d50049e3f48311f3dbe372803d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4
LcmZ4UmVp%j1%Lsc

diff --git a/.tool-versions b/server/.tool-versions
similarity index 100%
rename from .tool-versions
rename to server/.tool-versions
diff --git a/server/Makefile b/server/Makefile
index f75cdb9ab..601a4cca0 100644
--- a/server/Makefile
+++ b/server/Makefile
@@ -12,7 +12,7 @@ format:
 	mvn $(MVN_ARGS) spotless:apply
 
 # `test` only runs unit tests
-test: 
+test:
 	R_BIN=$(R) mvn $(MVN_ARGS) test
 
 # `verify` runs both tests and static analyses

From 1dced1fe13d80185ab693c204decc3272c5c7fd6 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 7 Aug 2024 16:56:07 +0200
Subject: [PATCH 32/80] Env variables for the paths to R and to libraries

---
 .../src/main/java/org/prlprg/AppConfig.java   | 22 ++++++++++++++++++-
 .../java/org/prlprg/session/GNURSession.java  |  1 +
 .../org/prlprg/rsession/GNURSessionTest.java  |  8 +++----
 3 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/server/src/main/java/org/prlprg/AppConfig.java b/server/src/main/java/org/prlprg/AppConfig.java
index d59981766..f87d225dd 100644
--- a/server/src/main/java/org/prlprg/AppConfig.java
+++ b/server/src/main/java/org/prlprg/AppConfig.java
@@ -1,5 +1,9 @@
 package org.prlprg;
 
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.prlprg.ir.cfg.CFG;
 import org.prlprg.ir.closure.CodeObject;
 import org.prlprg.util.Strings;
 
@@ -18,6 +22,22 @@ public final class AppConfig extends Config {
    */
   public static final String R_BIN = get("R_BIN", "R");
 
+  /**
+   * R library paths. There are the paths that the compile server will look libraries for in. We
+   * could call `.libPaths()` in R to get the paths R knows, but we also want to support custom
+   * paths?
+   */
+  public static final ArrayList<Path> R_LIBS = new ArrayList<>();
+
+  static {
+    String defaultRlibs = "~/R/x86_64-pc-linux-gnu-library/4.3/:/usr/lib/R/library";
+    defaultRlibs = defaultRlibs.replaceFirst("^~", System.getProperty("user.home"));
+    String r_libs = get("R_LIBS", defaultRlibs);
+    if (r_libs != null) {
+      R_LIBS.addAll(Arrays.stream(r_libs.split(":")).map(Path::of).toList());
+    }
+  }
+
   /**
    * Adds extra verification checks.
    *
@@ -28,7 +48,7 @@ public final class AppConfig extends Config {
   /**
    * Whether to verify phi inputs' incoming basic block when they are added.
    *
-   * <p>They are always verified during {@linkplain org.prlprg.ir.cfg.CFG#verify()} verification
+   * <p>They are always verified during {@linkplain CFG#verify()} verification
    *
    * <p><b>Default:</b>: true
    */
diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index d5ddf436a..0c51e582b 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -91,6 +91,7 @@ public void setCranMirror(URI uri) {}
 
   // We should also handle installation of a package from a GitHub repo?
   public void loadPackage(String name, String version) {
+    // TODO support RLibraries with multiple paths
     // Check if package is installed and if not install it
     var pkgPath = RLibraries.resolve(name);
     var pkgDir = pkgPath.toFile();
diff --git a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index f17714cf0..1ea06fcce 100644
--- a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -1,5 +1,7 @@
 package org.prlprg.rsession;
 
+import static org.prlprg.AppConfig.R_LIBS;
+
 import java.io.IOException;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Assertions;
@@ -12,10 +14,8 @@ public class GNURSessionTest {
 
   @Test
   public void testReadPackageDatabase() throws IOException {
-    var r_dir = Path.of("/usr/lib/R/");
-    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.3/";
-    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
-    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+    var p = Path.of("/usr/lib/R/");
+    var session = new GNURSession(RVersion.LATEST_AWARE, p, R_LIBS.get(0));
 
     session.loadPackage("yaml", "2.3.8");
 

From d2e87bd59246ef47d50be5393645555af5533a8b Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 7 Aug 2024 18:09:32 +0200
Subject: [PATCH 33/80] Proto files in a folder at teh root of the project so
 that they can be shared between java and C++

---
 .gitignore           |   2 +
 .gitmodules          |   1 +
 proto/README.md      |  29 ++++++++
 proto/messages.proto | 173 +++++++++++++++++++++++++++++++++++++++++++
 proto/routes.proto   |  20 +++++
 5 files changed, 225 insertions(+)
 create mode 100644 proto/README.md
 create mode 100644 proto/messages.proto
 create mode 100644 proto/routes.proto

diff --git a/.gitignore b/.gitignore
index fead68e84..021a4647e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,5 @@
 ### R ###
 .RData
 .Rhistory
+external/R/doc/manual/*.html
+external/R/doc/NEWS.pdf
diff --git a/.gitmodules b/.gitmodules
index 353157640..38cc202c0 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,4 @@
 [submodule "external/R"]
 	path = external/R
 	url = https://github.com/PRL-PRG/r-compiler-server-gnur
+	ignore = untracked
diff --git a/proto/README.md b/proto/README.md
new file mode 100644
index 000000000..a5530602a
--- /dev/null
+++ b/proto/README.md
@@ -0,0 +1,29 @@
+# Protocol  
+
+The communication between the client and the server is done through gRPC. 
+
+## Files
+
+- messages.proto: messages exchanged between the client and the server
+- routes.proto: services exposed by the server with the remote functions.
+
+## Services
+
+- `CompileService` runs on the server side to compile the code and return the result. It also has 
+ an `Init` route to initialize the server (version of R on the client...)
+- `FactService` runs on the client side and is interrogated by the server to get information to compile functions, 
+  for instance, a value in an environment.
+
+
+## Generating the code
+
+Make sure you have `protoc` installed.
+
+## Java
+
+Just compile the project through your IDE or with maven. The code will be generated in the `target/generated-sources/protobuf/grpc-java` and 
+ `target/generated-sources/protobuf/java`  folders. They are both part of the `server` package.
+
+## C++ 
+
+Run the `Makefile` at the root of the project as `make proto`. The code will be generated in the `client/rsh/src` folder.
\ No newline at end of file
diff --git a/proto/messages.proto b/proto/messages.proto
new file mode 100644
index 000000000..952a1348d
--- /dev/null
+++ b/proto/messages.proto
@@ -0,0 +1,173 @@
+syntax = "proto3";
+
+option java_package = "org.prlprg.server";
+
+// Error handling
+// grpc already has a way to handle errors
+// Status message: https://grpc.github.io/grpc-java/javadoc/io/grpc/Status.html
+
+// Init
+message Version {
+  int32 major = 1;
+  int32 minor = 2;
+  int32 patch = 3;
+}
+
+message InitRequest {
+  Version Rsh_version = 1;// version of the compile server
+  Version R_version = 2;
+  string platform = 3;//amd64, etc TODO: use an enum for the allowed platforms?
+  repeated bytes package_hash = 4;//Packages which are initially part of the environment (in addition to base)
+}
+
+message InitResponse {}
+
+
+// Basic messages
+
+message CompileRequest {
+  Function function = 2;// Add package version
+  optional Tier tier = 4;//if not defined, let the compile server decide
+  optional int32 optimization_level = 5;// if not defined, the server decides
+  optional Context context = 6;
+  optional Environment environment = 7;//The values of all the bindings that statically appear in the function
+}
+
+message CompileResponse {
+  bytes hash = 1;
+  Tier tier = 2;
+  optional bytes code = 3;
+  optional bytes constant_pool = 4;
+}
+
+
+message Function {
+  bytes package_hash = 1;
+  string name = 2; //What if it is a closure passed to a HOF?
+  bytes hash = 3;
+  optional bytes body = 4;
+  // what about the function parameters?
+}
+
+message FunctionRequest {
+  bytes hash = 1;
+}
+
+message Environment {
+  map<string, bytes> values = 1;//Name of the variable to a hash of the value
+}
+
+
+message ValueRequest {
+  repeated bytes hash = 1;// We can batch and ask for several values
+}
+
+message Value {
+  bytes hash = 1;
+  bytes value = 2;
+}
+message Values {
+  repeated Value values = 1;
+}
+
+message Empty {}
+
+enum Tier {
+  BASELINE = 0;// bytecode
+  OPTIMIZED = 1; // native code
+}
+
+// Context
+
+message CallContext {
+  bool args_statically_matched = 1;
+  bool correct_number_of_args = 2;
+  bool correct_order_of_args = 3;
+  bool no_missing_args = 4;
+}
+
+message ArgumentContext {
+  bool eager = 1;
+  bool reflection = 2;
+  bool object = 3;
+  optional Type type = 4;
+}
+
+message Context {
+  CallContext call_context = 1;
+  repeated ArgumentContext argument_context = 2;
+}
+
+message ContextRequest {
+  Function function = 1;
+}
+
+
+// Feedback
+
+enum TestLattice {
+  BOTH = 0;
+  ONLY_TRUE = 1;
+  ONLY_FALSE = 2;
+  NONE = 3;
+}
+
+enum Type {
+  ANY = 0;
+  INTEGER = 1;
+  REAL = 2;// Add more types
+}
+
+message TestFeedback {
+  TestLattice test_lattice = 1;
+}
+
+message CallFeedback {
+  int64 n_calls = 1;
+  bytes callee_hash = 2;
+}
+
+message ValueFeedback {
+  bool scalar = 1;
+  bool object = 2;
+  bool accessed_attributes = 3;
+  bool vectorizable = 4;
+  bool is_promise = 5;
+}
+
+message TypeFeedback {
+  message Feedback {
+    oneof feedback {
+      TestFeedback test_feedback = 1;
+      CallFeedback call_feedback = 2;
+      ValueFeedback value_feedback = 3;
+    }
+  }
+  map<int64, Feedback> types = 2;//Offset in the bytecode to the feedback
+}
+
+message FeedbackRequest {
+  Function function = 1;
+}
+
+// Packages
+
+
+message PackageSource {
+  oneof source {
+    string r_mirror = 2;
+    string github_url = 3;
+  }
+}
+
+message Package {
+  string name = 1;
+  Version version = 2;
+  repeated bytes function_hashes = 4;
+  // What about package data? Maybe just the sysdata?
+  optional PackageSource source = 5;//If none, it is a base package or a local package
+}
+
+message PackageRequest {
+  bytes hash = 1;
+}
\ No newline at end of file
diff --git a/proto/routes.proto b/proto/routes.proto
new file mode 100644
index 000000000..ac6775360
--- /dev/null
+++ b/proto/routes.proto
@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+option java_package = "org.prlprg.server";
+
+import "messages.proto";
+
+// R sends requests to the compile server
+service CompileService {
+  rpc Compile(CompileRequest) returns (CompileResponse) {}
+  rpc Init(InitRequest) returns (InitResponse) {}
+}
+
+// Used by the compile server to ask questions to R
+// The server part there should be in the C++ code
+service FactService {
+  rpc GetContext(ContextRequest) returns (Context) {}
+  rpc GetTypeFeedback(FeedbackRequest) returns (TypeFeedback) {}
+  rpc GetValues(ValueRequest) returns (Values) {}
+  rpc GetFunction(FunctionRequest) returns (Function) {}
+}
\ No newline at end of file

From a3ac20a0f48af0694eadce1f56b7c04281cbdb72 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 8 Aug 2024 16:00:44 +0200
Subject: [PATCH 34/80] Update R version

---
 client/protocol/Makefile      |    3 +-
 client/rsh/src/protocol.pb.cc | 1607 ++++++++++++++++-----------------
 client/rsh/src/protocol.pb.h  | 1479 ++++++++++++------------------
 external/R                    |    2 +-
 4 files changed, 1372 insertions(+), 1719 deletions(-)

diff --git a/client/protocol/Makefile b/client/protocol/Makefile
index bfa6a4101..09587581c 100644
--- a/client/protocol/Makefile
+++ b/client/protocol/Makefile
@@ -1,5 +1,4 @@
 CPP_DEST := ../rsh/src
-JAVA_DEST := ../../src/main/java
 
 all:
-	protoc --cpp_out=$(CPP_DEST) --java_out=$(JAVA_DEST) protocol.proto
+	protoc --cpp_out=$(CPP_DEST) protocol.proto
diff --git a/client/rsh/src/protocol.pb.cc b/client/rsh/src/protocol.pb.cc
index dc8d9797c..a61c66dc7 100644
--- a/client/rsh/src/protocol.pb.cc
+++ b/client/rsh/src/protocol.pb.cc
@@ -14,174 +14,160 @@
 #include <google/protobuf/wire_format.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
-extern PROTOBUF_INTERNAL_EXPORT_protocol_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompileRequest_protocol_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_protocol_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompiledFunction_protocol_2eproto;
-extern PROTOBUF_INTERNAL_EXPORT_protocol_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HandshakeRequest_protocol_2eproto;
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
 namespace rsh {
 namespace server {
 namespace protocol {
-class RequestDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Request> _instance;
-  const ::rsh::server::protocol::HandshakeRequest* handshake_;
-  const ::rsh::server::protocol::CompileRequest* compile_;
-} _Request_default_instance_;
-class HandshakeRequestDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<HandshakeRequest> _instance;
-} _HandshakeRequest_default_instance_;
-class CompileRequestDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CompileRequest> _instance;
-} _CompileRequest_default_instance_;
-class CompiledFunctionDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CompiledFunction> _instance;
-} _CompiledFunction_default_instance_;
-class CompileResponseDefaultTypeInternal {
- public:
-  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CompileResponse> _instance;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr failure_;
-  const ::rsh::server::protocol::CompiledFunction* result_;
-} _CompileResponse_default_instance_;
+PROTOBUF_CONSTEXPR Request::Request(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.payload_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct RequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR RequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~RequestDefaultTypeInternal() {}
+  union {
+    Request _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestDefaultTypeInternal _Request_default_instance_;
+PROTOBUF_CONSTEXPR HandshakeRequest::HandshakeRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.packages_)*/{}
+  , /*decltype(_impl_.rsh_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.r_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.platform_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct HandshakeRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HandshakeRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HandshakeRequestDefaultTypeInternal() {}
+  union {
+    HandshakeRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_;
+PROTOBUF_CONSTEXPR CompileRequest::CompileRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.closure_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.bc_optimization_)*/0u
+  , /*decltype(_impl_.cc_optimization_)*/0u
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct CompileRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CompileRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CompileRequestDefaultTypeInternal() {}
+  union {
+    CompileRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompileRequestDefaultTypeInternal _CompileRequest_default_instance_;
+PROTOBUF_CONSTEXPR CompiledFunction::CompiledFunction(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.native_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.constants_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct CompiledFunctionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CompiledFunctionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CompiledFunctionDefaultTypeInternal() {}
+  union {
+    CompiledFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompiledFunctionDefaultTypeInternal _CompiledFunction_default_instance_;
+PROTOBUF_CONSTEXPR CompileResponse::CompileResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.data_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct CompileResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CompileResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CompileResponseDefaultTypeInternal() {}
+  union {
+    CompileResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompileResponseDefaultTypeInternal _CompileResponse_default_instance_;
 }  // namespace protocol
 }  // namespace server
 }  // namespace rsh
-static void InitDefaultsscc_info_CompileRequest_protocol_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::rsh::server::protocol::_CompileRequest_default_instance_;
-    new (ptr) ::rsh::server::protocol::CompileRequest();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::rsh::server::protocol::CompileRequest::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompileRequest_protocol_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CompileRequest_protocol_2eproto}, {}};
-
-static void InitDefaultsscc_info_CompileResponse_protocol_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::rsh::server::protocol::_CompileResponse_default_instance_;
-    new (ptr) ::rsh::server::protocol::CompileResponse();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::rsh::server::protocol::CompileResponse::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CompileResponse_protocol_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_CompileResponse_protocol_2eproto}, {
-      &scc_info_CompiledFunction_protocol_2eproto.base,}};
+static ::_pb::Metadata file_level_metadata_protocol_2eproto[5];
+static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_protocol_2eproto = nullptr;
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_protocol_2eproto = nullptr;
 
-static void InitDefaultsscc_info_CompiledFunction_protocol_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::rsh::server::protocol::_CompiledFunction_default_instance_;
-    new (ptr) ::rsh::server::protocol::CompiledFunction();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::rsh::server::protocol::CompiledFunction::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompiledFunction_protocol_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CompiledFunction_protocol_2eproto}, {}};
-
-static void InitDefaultsscc_info_HandshakeRequest_protocol_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::rsh::server::protocol::_HandshakeRequest_default_instance_;
-    new (ptr) ::rsh::server::protocol::HandshakeRequest();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::rsh::server::protocol::HandshakeRequest::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HandshakeRequest_protocol_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_HandshakeRequest_protocol_2eproto}, {}};
-
-static void InitDefaultsscc_info_Request_protocol_2eproto() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  {
-    void* ptr = &::rsh::server::protocol::_Request_default_instance_;
-    new (ptr) ::rsh::server::protocol::Request();
-    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::rsh::server::protocol::Request::InitAsDefaultInstance();
-}
-
-::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Request_protocol_2eproto =
-    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_Request_protocol_2eproto}, {
-      &scc_info_HandshakeRequest_protocol_2eproto.base,
-      &scc_info_CompileRequest_protocol_2eproto.base,}};
-
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_protocol_2eproto[5];
-static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_protocol_2eproto = nullptr;
-static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_protocol_2eproto = nullptr;
-
-const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_protocol_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+const uint32_t TableStruct_protocol_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _internal_metadata_),
   ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _oneof_case_[0]),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _impl_._oneof_case_[0]),
   ~0u,  // no _weak_field_map_
-  offsetof(::rsh::server::protocol::RequestDefaultTypeInternal, handshake_),
-  offsetof(::rsh::server::protocol::RequestDefaultTypeInternal, compile_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, payload_),
+  ~0u,  // no _inlined_string_donated_
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _impl_.payload_),
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, rsh_version_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, r_version_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, platform_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, packages_),
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.rsh_version_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.r_version_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.platform_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.packages_),
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, name_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, closure_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, bc_optimization_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, cc_optimization_),
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.closure_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.bc_optimization_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.cc_optimization_),
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, name_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, native_code_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, constants_),
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _impl_.native_code_),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _impl_.constants_),
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _internal_metadata_),
   ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _oneof_case_[0]),
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _impl_._oneof_case_[0]),
   ~0u,  // no _weak_field_map_
-  offsetof(::rsh::server::protocol::CompileResponseDefaultTypeInternal, failure_),
-  offsetof(::rsh::server::protocol::CompileResponseDefaultTypeInternal, result_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, data_),
+  ~0u,  // no _inlined_string_donated_
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _impl_.data_),
 };
-static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, -1, sizeof(::rsh::server::protocol::Request)},
-  { 8, -1, sizeof(::rsh::server::protocol::HandshakeRequest)},
-  { 17, -1, sizeof(::rsh::server::protocol::CompileRequest)},
-  { 26, -1, sizeof(::rsh::server::protocol::CompiledFunction)},
-  { 34, -1, sizeof(::rsh::server::protocol::CompileResponse)},
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::rsh::server::protocol::Request)},
+  { 9, -1, -1, sizeof(::rsh::server::protocol::HandshakeRequest)},
+  { 19, -1, -1, sizeof(::rsh::server::protocol::CompileRequest)},
+  { 29, -1, -1, sizeof(::rsh::server::protocol::CompiledFunction)},
+  { 38, -1, -1, sizeof(::rsh::server::protocol::CompileResponse)},
 };
 
-static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::rsh::server::protocol::_Request_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::rsh::server::protocol::_HandshakeRequest_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::rsh::server::protocol::_CompileRequest_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::rsh::server::protocol::_CompiledFunction_default_instance_),
-  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::rsh::server::protocol::_CompileResponse_default_instance_),
+static const ::_pb::Message* const file_default_instances[] = {
+  &::rsh::server::protocol::_Request_default_instance_._instance,
+  &::rsh::server::protocol::_HandshakeRequest_default_instance_._instance,
+  &::rsh::server::protocol::_CompileRequest_default_instance_._instance,
+  &::rsh::server::protocol::_CompiledFunction_default_instance_._instance,
+  &::rsh::server::protocol::_CompileResponse_default_instance_._instance,
 };
 
 const char descriptor_table_protodef_protocol_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
@@ -201,37 +187,27 @@ const char descriptor_table_protodef_protocol_2eproto[] PROTOBUF_SECTION_VARIABL
   "l.CompiledFunctionH\000B\006\n\004dataB\036\n\032org.prlp"
   "rg.server.protocolP\001b\006proto3"
   ;
-static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_protocol_2eproto_deps[1] = {
-};
-static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_protocol_2eproto_sccs[5] = {
-  &scc_info_CompileRequest_protocol_2eproto.base,
-  &scc_info_CompileResponse_protocol_2eproto.base,
-  &scc_info_CompiledFunction_protocol_2eproto.base,
-  &scc_info_HandshakeRequest_protocol_2eproto.base,
-  &scc_info_Request_protocol_2eproto.base,
-};
-static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_protocol_2eproto_once;
-const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protocol_2eproto = {
-  false, false, descriptor_table_protodef_protocol_2eproto, "protocol.proto", 588,
-  &descriptor_table_protocol_2eproto_once, descriptor_table_protocol_2eproto_sccs, descriptor_table_protocol_2eproto_deps, 5, 0,
-  schemas, file_default_instances, TableStruct_protocol_2eproto::offsets,
-  file_level_metadata_protocol_2eproto, 5, file_level_enum_descriptors_protocol_2eproto, file_level_service_descriptors_protocol_2eproto,
+static ::_pbi::once_flag descriptor_table_protocol_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_protocol_2eproto = {
+    false, false, 588, descriptor_table_protodef_protocol_2eproto,
+    "protocol.proto",
+    &descriptor_table_protocol_2eproto_once, nullptr, 0, 5,
+    schemas, file_default_instances, TableStruct_protocol_2eproto::offsets,
+    file_level_metadata_protocol_2eproto, file_level_enum_descriptors_protocol_2eproto,
+    file_level_service_descriptors_protocol_2eproto,
 };
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_protocol_2eproto_getter() {
+  return &descriptor_table_protocol_2eproto;
+}
 
 // Force running AddDescriptors() at dynamic initialization time.
-static bool dynamic_init_dummy_protocol_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_protocol_2eproto)), true);
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_protocol_2eproto(&descriptor_table_protocol_2eproto);
 namespace rsh {
 namespace server {
 namespace protocol {
 
 // ===================================================================
 
-void Request::InitAsDefaultInstance() {
-  ::rsh::server::protocol::_Request_default_instance_.handshake_ = const_cast< ::rsh::server::protocol::HandshakeRequest*>(
-      ::rsh::server::protocol::HandshakeRequest::internal_default_instance());
-  ::rsh::server::protocol::_Request_default_instance_.compile_ = const_cast< ::rsh::server::protocol::CompileRequest*>(
-      ::rsh::server::protocol::CompileRequest::internal_default_instance());
-}
 class Request::_Internal {
  public:
   static const ::rsh::server::protocol::HandshakeRequest& handshake(const Request* msg);
@@ -240,59 +216,67 @@ class Request::_Internal {
 
 const ::rsh::server::protocol::HandshakeRequest&
 Request::_Internal::handshake(const Request* msg) {
-  return *msg->payload_.handshake_;
+  return *msg->_impl_.payload_.handshake_;
 }
 const ::rsh::server::protocol::CompileRequest&
 Request::_Internal::compile(const Request* msg) {
-  return *msg->payload_.compile_;
+  return *msg->_impl_.payload_.compile_;
 }
 void Request::set_allocated_handshake(::rsh::server::protocol::HandshakeRequest* handshake) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   clear_payload();
   if (handshake) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(handshake);
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(handshake);
     if (message_arena != submessage_arena) {
       handshake = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, handshake, submessage_arena);
     }
     set_has_handshake();
-    payload_.handshake_ = handshake;
+    _impl_.payload_.handshake_ = handshake;
   }
   // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.Request.handshake)
 }
 void Request::set_allocated_compile(::rsh::server::protocol::CompileRequest* compile) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   clear_payload();
   if (compile) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(compile);
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compile);
     if (message_arena != submessage_arena) {
       compile = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, compile, submessage_arena);
     }
     set_has_compile();
-    payload_.compile_ = compile;
+    _impl_.payload_.compile_ = compile;
   }
   // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.Request.compile)
 }
-Request::Request(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
+Request::Request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
   // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.Request)
 }
 Request::Request(const Request& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Request* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.payload_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   clear_has_payload();
   switch (from.payload_case()) {
     case kHandshake: {
-      _internal_mutable_handshake()->::rsh::server::protocol::HandshakeRequest::MergeFrom(from._internal_handshake());
+      _this->_internal_mutable_handshake()->::rsh::server::protocol::HandshakeRequest::MergeFrom(
+          from._internal_handshake());
       break;
     }
     case kCompile: {
-      _internal_mutable_compile()->::rsh::server::protocol::CompileRequest::MergeFrom(from._internal_compile());
+      _this->_internal_mutable_compile()->::rsh::server::protocol::CompileRequest::MergeFrom(
+          from._internal_compile());
       break;
     }
     case PAYLOAD_NOT_SET: {
@@ -302,51 +286,50 @@ Request::Request(const Request& from)
   // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.Request)
 }
 
-void Request::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Request_protocol_2eproto.base);
+inline void Request::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.payload_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
   clear_has_payload();
 }
 
 Request::~Request() {
   // @@protoc_insertion_point(destructor:rsh.server.protocol.Request)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
   SharedDtor();
-  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void Request::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
+inline void Request::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
   if (has_payload()) {
     clear_payload();
   }
 }
 
-void Request::ArenaDtor(void* object) {
-  Request* _this = reinterpret_cast< Request* >(object);
-  (void)_this;
-}
-void Request::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
 void Request::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
+  _impl_._cached_size_.Set(size);
 }
-const Request& Request::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Request_protocol_2eproto.base);
-  return *internal_default_instance();
-}
-
 
 void Request::clear_payload() {
 // @@protoc_insertion_point(one_of_clear_start:rsh.server.protocol.Request)
   switch (payload_case()) {
     case kHandshake: {
-      if (GetArena() == nullptr) {
-        delete payload_.handshake_;
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.payload_.handshake_;
       }
       break;
     }
     case kCompile: {
-      if (GetArena() == nullptr) {
-        delete payload_.compile_;
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.payload_.compile_;
       }
       break;
     }
@@ -354,13 +337,13 @@ void Request::clear_payload() {
       break;
     }
   }
-  _oneof_case_[0] = PAYLOAD_NOT_SET;
+  _impl_._oneof_case_[0] = PAYLOAD_NOT_SET;
 }
 
 
 void Request::Clear() {
 // @@protoc_insertion_point(message_clear_start:rsh.server.protocol.Request)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
@@ -368,74 +351,73 @@ void Request::Clear() {
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* Request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* Request::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
   while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
       // .rsh.server.protocol.HandshakeRequest handshake = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr = ctx->ParseMessage(_internal_mutable_handshake(), ptr);
           CHK_(ptr);
-        } else goto handle_unusual;
+        } else
+          goto handle_unusual;
         continue;
       // .rsh.server.protocol.CompileRequest compile = 2;
       case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr = ctx->ParseMessage(_internal_mutable_compile(), ptr);
           CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
+        } else
+          goto handle_unusual;
         continue;
-      }
+      default:
+        goto handle_unusual;
     }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
   }  // while
-success:
+message_done:
   return ptr;
 failure:
   ptr = nullptr;
-  goto success;
+  goto message_done;
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* Request::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+uint8_t* Request::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.Request)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   // .rsh.server.protocol.HandshakeRequest handshake = 1;
   if (_internal_has_handshake()) {
-    target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        1, _Internal::handshake(this), target, stream);
+      InternalWriteMessage(1, _Internal::handshake(this),
+        _Internal::handshake(this).GetCachedSize(), target, stream);
   }
 
   // .rsh.server.protocol.CompileRequest compile = 2;
   if (_internal_has_compile()) {
-    target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        2, _Internal::compile(this), target, stream);
+      InternalWriteMessage(2, _Internal::compile(this),
+        _Internal::compile(this).GetCachedSize(), target, stream);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.Request)
@@ -446,7 +428,7 @@ size_t Request::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.Request)
   size_t total_size = 0;
 
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
@@ -455,71 +437,54 @@ size_t Request::ByteSizeLong() const {
     case kHandshake: {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *payload_.handshake_);
+          *_impl_.payload_.handshake_);
       break;
     }
     // .rsh.server.protocol.CompileRequest compile = 2;
     case kCompile: {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *payload_.compile_);
+          *_impl_.payload_.compile_);
       break;
     }
     case PAYLOAD_NOT_SET: {
       break;
     }
   }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
-        _internal_metadata_, total_size, &_cached_size_);
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-void Request::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:rsh.server.protocol.Request)
-  GOOGLE_DCHECK_NE(&from, this);
-  const Request* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Request>(
-          &from);
-  if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rsh.server.protocol.Request)
-    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:rsh.server.protocol.Request)
-    MergeFrom(*source);
-  }
-}
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Request::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Request::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Request::GetClassData() const { return &_class_data_; }
 
-void Request::MergeFrom(const Request& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.Request)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+
+void Request::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Request*>(&to_msg);
+  auto& from = static_cast<const Request&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.Request)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   switch (from.payload_case()) {
     case kHandshake: {
-      _internal_mutable_handshake()->::rsh::server::protocol::HandshakeRequest::MergeFrom(from._internal_handshake());
+      _this->_internal_mutable_handshake()->::rsh::server::protocol::HandshakeRequest::MergeFrom(
+          from._internal_handshake());
       break;
     }
     case kCompile: {
-      _internal_mutable_compile()->::rsh::server::protocol::CompileRequest::MergeFrom(from._internal_compile());
+      _this->_internal_mutable_compile()->::rsh::server::protocol::CompileRequest::MergeFrom(
+          from._internal_compile());
       break;
     }
     case PAYLOAD_NOT_SET: {
       break;
     }
   }
-}
-
-void Request::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:rsh.server.protocol.Request)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void Request::CopyFrom(const Request& from) {
@@ -535,180 +500,208 @@ bool Request::IsInitialized() const {
 
 void Request::InternalSwap(Request* other) {
   using std::swap;
-  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  swap(payload_, other->payload_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.payload_, other->_impl_.payload_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata Request::GetMetadata() const {
-  return GetMetadataStatic();
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
+      file_level_metadata_protocol_2eproto[0]);
 }
 
-
 // ===================================================================
 
-void HandshakeRequest::InitAsDefaultInstance() {
-}
 class HandshakeRequest::_Internal {
  public:
 };
 
-HandshakeRequest::HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
-  packages_(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
+HandshakeRequest::HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
   // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.HandshakeRequest)
 }
 HandshakeRequest::HandshakeRequest(const HandshakeRequest& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message(),
-      packages_(from.packages_) {
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  HandshakeRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.packages_){from._impl_.packages_}
+    , decltype(_impl_.rsh_version_){}
+    , decltype(_impl_.r_version_){}
+    , decltype(_impl_.platform_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  rsh_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.rsh_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rsh_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_rsh_version().empty()) {
-    rsh_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_rsh_version(),
-      GetArena());
+    _this->_impl_.rsh_version_.Set(from._internal_rsh_version(), 
+      _this->GetArenaForAllocation());
   }
-  r_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.r_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.r_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_r_version().empty()) {
-    r_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_r_version(),
-      GetArena());
+    _this->_impl_.r_version_.Set(from._internal_r_version(), 
+      _this->GetArenaForAllocation());
   }
-  platform_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.platform_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.platform_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_platform().empty()) {
-    platform_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_platform(),
-      GetArena());
+    _this->_impl_.platform_.Set(from._internal_platform(), 
+      _this->GetArenaForAllocation());
   }
   // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.HandshakeRequest)
 }
 
-void HandshakeRequest::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HandshakeRequest_protocol_2eproto.base);
-  rsh_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  r_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  platform_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline void HandshakeRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.packages_){arena}
+    , decltype(_impl_.rsh_version_){}
+    , decltype(_impl_.r_version_){}
+    , decltype(_impl_.platform_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.rsh_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.rsh_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.r_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.r_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.platform_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.platform_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
 HandshakeRequest::~HandshakeRequest() {
   // @@protoc_insertion_point(destructor:rsh.server.protocol.HandshakeRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
   SharedDtor();
-  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void HandshakeRequest::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  rsh_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  r_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  platform_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline void HandshakeRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.packages_.~RepeatedPtrField();
+  _impl_.rsh_version_.Destroy();
+  _impl_.r_version_.Destroy();
+  _impl_.platform_.Destroy();
 }
 
-void HandshakeRequest::ArenaDtor(void* object) {
-  HandshakeRequest* _this = reinterpret_cast< HandshakeRequest* >(object);
-  (void)_this;
-}
-void HandshakeRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
 void HandshakeRequest::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const HandshakeRequest& HandshakeRequest::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HandshakeRequest_protocol_2eproto.base);
-  return *internal_default_instance();
+  _impl_._cached_size_.Set(size);
 }
 
-
 void HandshakeRequest::Clear() {
 // @@protoc_insertion_point(message_clear_start:rsh.server.protocol.HandshakeRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  packages_.Clear();
-  rsh_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  r_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  platform_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.packages_.Clear();
+  _impl_.rsh_version_.ClearToEmpty();
+  _impl_.r_version_.ClearToEmpty();
+  _impl_.platform_.ClearToEmpty();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* HandshakeRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* HandshakeRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
   while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
       // string Rsh_version = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           auto str = _internal_mutable_rsh_version();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.Rsh_version"));
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.Rsh_version"));
+        } else
+          goto handle_unusual;
         continue;
       // string R_version = 2;
       case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           auto str = _internal_mutable_r_version();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.R_version"));
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.R_version"));
+        } else
+          goto handle_unusual;
         continue;
       // string platform = 3;
       case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
           auto str = _internal_mutable_platform();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.platform"));
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.platform"));
+        } else
+          goto handle_unusual;
         continue;
       // repeated string packages = 4;
       case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
           ptr -= 1;
           do {
             ptr += 1;
             auto str = _internal_add_packages();
-            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.packages"));
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
             CHK_(ptr);
+            CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.packages"));
             if (!ctx->DataAvailable(ptr)) break;
           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
+        } else
+          goto handle_unusual;
         continue;
-      }
+      default:
+        goto handle_unusual;
     }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
   }  // while
-success:
+message_done:
   return ptr;
 failure:
   ptr = nullptr;
-  goto success;
+  goto message_done;
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* HandshakeRequest::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+uint8_t* HandshakeRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.HandshakeRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   // string Rsh_version = 1;
-  if (this->rsh_version().size() > 0) {
+  if (!this->_internal_rsh_version().empty()) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_rsh_version().data(), static_cast<int>(this->_internal_rsh_version().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
@@ -718,7 +711,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* HandshakeRequest::_InternalSerialize(
   }
 
   // string R_version = 2;
-  if (this->r_version().size() > 0) {
+  if (!this->_internal_r_version().empty()) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_r_version().data(), static_cast<int>(this->_internal_r_version().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
@@ -728,7 +721,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* HandshakeRequest::_InternalSerialize(
   }
 
   // string platform = 3;
-  if (this->platform().size() > 0) {
+  if (!this->_internal_platform().empty()) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_platform().data(), static_cast<int>(this->_internal_platform().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
@@ -748,7 +741,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* HandshakeRequest::_InternalSerialize(
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.HandshakeRequest)
@@ -759,87 +752,68 @@ size_t HandshakeRequest::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.HandshakeRequest)
   size_t total_size = 0;
 
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
   // repeated string packages = 4;
   total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(packages_.size());
-  for (int i = 0, n = packages_.size(); i < n; i++) {
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.packages_.size());
+  for (int i = 0, n = _impl_.packages_.size(); i < n; i++) {
     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      packages_.Get(i));
+      _impl_.packages_.Get(i));
   }
 
   // string Rsh_version = 1;
-  if (this->rsh_version().size() > 0) {
+  if (!this->_internal_rsh_version().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
         this->_internal_rsh_version());
   }
 
   // string R_version = 2;
-  if (this->r_version().size() > 0) {
+  if (!this->_internal_r_version().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
         this->_internal_r_version());
   }
 
   // string platform = 3;
-  if (this->platform().size() > 0) {
+  if (!this->_internal_platform().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
         this->_internal_platform());
   }
 
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
-        _internal_metadata_, total_size, &_cached_size_);
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-void HandshakeRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:rsh.server.protocol.HandshakeRequest)
-  GOOGLE_DCHECK_NE(&from, this);
-  const HandshakeRequest* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<HandshakeRequest>(
-          &from);
-  if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rsh.server.protocol.HandshakeRequest)
-    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:rsh.server.protocol.HandshakeRequest)
-    MergeFrom(*source);
-  }
-}
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    HandshakeRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeRequest::GetClassData() const { return &_class_data_; }
 
-void HandshakeRequest::MergeFrom(const HandshakeRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.HandshakeRequest)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+
+void HandshakeRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<HandshakeRequest*>(&to_msg);
+  auto& from = static_cast<const HandshakeRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.HandshakeRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  packages_.MergeFrom(from.packages_);
-  if (from.rsh_version().size() > 0) {
-    _internal_set_rsh_version(from._internal_rsh_version());
+  _this->_impl_.packages_.MergeFrom(from._impl_.packages_);
+  if (!from._internal_rsh_version().empty()) {
+    _this->_internal_set_rsh_version(from._internal_rsh_version());
   }
-  if (from.r_version().size() > 0) {
-    _internal_set_r_version(from._internal_r_version());
+  if (!from._internal_r_version().empty()) {
+    _this->_internal_set_r_version(from._internal_r_version());
   }
-  if (from.platform().size() > 0) {
-    _internal_set_platform(from._internal_platform());
+  if (!from._internal_platform().empty()) {
+    _this->_internal_set_platform(from._internal_platform());
   }
-}
-
-void HandshakeRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:rsh.server.protocol.HandshakeRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void HandshakeRequest::CopyFrom(const HandshakeRequest& from) {
@@ -855,170 +829,201 @@ bool HandshakeRequest::IsInitialized() const {
 
 void HandshakeRequest::InternalSwap(HandshakeRequest* other) {
   using std::swap;
-  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  packages_.InternalSwap(&other->packages_);
-  rsh_version_.Swap(&other->rsh_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  r_version_.Swap(&other->r_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  platform_.Swap(&other->platform_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.packages_.InternalSwap(&other->_impl_.packages_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.rsh_version_, lhs_arena,
+      &other->_impl_.rsh_version_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.r_version_, lhs_arena,
+      &other->_impl_.r_version_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.platform_, lhs_arena,
+      &other->_impl_.platform_, rhs_arena
+  );
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata HandshakeRequest::GetMetadata() const {
-  return GetMetadataStatic();
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
+      file_level_metadata_protocol_2eproto[1]);
 }
 
-
 // ===================================================================
 
-void CompileRequest::InitAsDefaultInstance() {
-}
 class CompileRequest::_Internal {
  public:
 };
 
-CompileRequest::CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
+CompileRequest::CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
   // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.CompileRequest)
 }
 CompileRequest::CompileRequest(const CompileRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CompileRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.name_){}
+    , decltype(_impl_.closure_){}
+    , decltype(_impl_.bc_optimization_){}
+    , decltype(_impl_.cc_optimization_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_name().empty()) {
-    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
   }
-  closure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.closure_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.closure_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_closure().empty()) {
-    closure_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_closure(),
-      GetArena());
+    _this->_impl_.closure_.Set(from._internal_closure(), 
+      _this->GetArenaForAllocation());
   }
-  ::memcpy(&bc_optimization_, &from.bc_optimization_,
-    static_cast<size_t>(reinterpret_cast<char*>(&cc_optimization_) -
-    reinterpret_cast<char*>(&bc_optimization_)) + sizeof(cc_optimization_));
+  ::memcpy(&_impl_.bc_optimization_, &from._impl_.bc_optimization_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cc_optimization_) -
+    reinterpret_cast<char*>(&_impl_.bc_optimization_)) + sizeof(_impl_.cc_optimization_));
   // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.CompileRequest)
 }
 
-void CompileRequest::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompileRequest_protocol_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  closure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::memset(&bc_optimization_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&cc_optimization_) -
-      reinterpret_cast<char*>(&bc_optimization_)) + sizeof(cc_optimization_));
+inline void CompileRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.name_){}
+    , decltype(_impl_.closure_){}
+    , decltype(_impl_.bc_optimization_){0u}
+    , decltype(_impl_.cc_optimization_){0u}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.closure_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.closure_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
 CompileRequest::~CompileRequest() {
   // @@protoc_insertion_point(destructor:rsh.server.protocol.CompileRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
   SharedDtor();
-  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void CompileRequest::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  closure_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline void CompileRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.closure_.Destroy();
 }
 
-void CompileRequest::ArenaDtor(void* object) {
-  CompileRequest* _this = reinterpret_cast< CompileRequest* >(object);
-  (void)_this;
-}
-void CompileRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
 void CompileRequest::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const CompileRequest& CompileRequest::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompileRequest_protocol_2eproto.base);
-  return *internal_default_instance();
+  _impl_._cached_size_.Set(size);
 }
 
-
 void CompileRequest::Clear() {
 // @@protoc_insertion_point(message_clear_start:rsh.server.protocol.CompileRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  closure_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  ::memset(&bc_optimization_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&cc_optimization_) -
-      reinterpret_cast<char*>(&bc_optimization_)) + sizeof(cc_optimization_));
+  _impl_.name_.ClearToEmpty();
+  _impl_.closure_.ClearToEmpty();
+  ::memset(&_impl_.bc_optimization_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.cc_optimization_) -
+      reinterpret_cast<char*>(&_impl_.bc_optimization_)) + sizeof(_impl_.cc_optimization_));
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* CompileRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
   while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
       // string name = 2;
       case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.CompileRequest.name"));
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.CompileRequest.name"));
+        } else
+          goto handle_unusual;
         continue;
       // bytes closure = 3;
       case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
           auto str = _internal_mutable_closure();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+        } else
+          goto handle_unusual;
         continue;
       // uint32 bc_optimization = 4;
       case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
-          bc_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _impl_.bc_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
           CHK_(ptr);
-        } else goto handle_unusual;
+        } else
+          goto handle_unusual;
         continue;
       // uint32 cc_optimization = 5;
       case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
-          cc_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _impl_.cc_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
           CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
+        } else
+          goto handle_unusual;
         continue;
-      }
+      default:
+        goto handle_unusual;
     }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
   }  // while
-success:
+message_done:
   return ptr;
 failure:
   ptr = nullptr;
-  goto success;
+  goto message_done;
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* CompileRequest::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+uint8_t* CompileRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.CompileRequest)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   // string name = 2;
-  if (this->name().size() > 0) {
+  if (!this->_internal_name().empty()) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
@@ -1028,25 +1033,25 @@ ::PROTOBUF_NAMESPACE_ID::uint8* CompileRequest::_InternalSerialize(
   }
 
   // bytes closure = 3;
-  if (this->closure().size() > 0) {
+  if (!this->_internal_closure().empty()) {
     target = stream->WriteBytesMaybeAliased(
         3, this->_internal_closure(), target);
   }
 
   // uint32 bc_optimization = 4;
-  if (this->bc_optimization() != 0) {
+  if (this->_internal_bc_optimization() != 0) {
     target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bc_optimization(), target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bc_optimization(), target);
   }
 
   // uint32 cc_optimization = 5;
-  if (this->cc_optimization() != 0) {
+  if (this->_internal_cc_optimization() != 0) {
     target = stream->EnsureSpace(target);
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_cc_optimization(), target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_cc_optimization(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.CompileRequest)
@@ -1057,88 +1062,65 @@ size_t CompileRequest::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.CompileRequest)
   size_t total_size = 0;
 
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
   // string name = 2;
-  if (this->name().size() > 0) {
+  if (!this->_internal_name().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
         this->_internal_name());
   }
 
   // bytes closure = 3;
-  if (this->closure().size() > 0) {
+  if (!this->_internal_closure().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
         this->_internal_closure());
   }
 
   // uint32 bc_optimization = 4;
-  if (this->bc_optimization() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
-        this->_internal_bc_optimization());
+  if (this->_internal_bc_optimization() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bc_optimization());
   }
 
   // uint32 cc_optimization = 5;
-  if (this->cc_optimization() != 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
-        this->_internal_cc_optimization());
+  if (this->_internal_cc_optimization() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cc_optimization());
   }
 
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
-        _internal_metadata_, total_size, &_cached_size_);
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-void CompileRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:rsh.server.protocol.CompileRequest)
-  GOOGLE_DCHECK_NE(&from, this);
-  const CompileRequest* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CompileRequest>(
-          &from);
-  if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rsh.server.protocol.CompileRequest)
-    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:rsh.server.protocol.CompileRequest)
-    MergeFrom(*source);
-  }
-}
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompileRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CompileRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileRequest::GetClassData() const { return &_class_data_; }
 
-void CompileRequest::MergeFrom(const CompileRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompileRequest)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+
+void CompileRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CompileRequest*>(&to_msg);
+  auto& from = static_cast<const CompileRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompileRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
+  if (!from._internal_name().empty()) {
+    _this->_internal_set_name(from._internal_name());
   }
-  if (from.closure().size() > 0) {
-    _internal_set_closure(from._internal_closure());
+  if (!from._internal_closure().empty()) {
+    _this->_internal_set_closure(from._internal_closure());
   }
-  if (from.bc_optimization() != 0) {
-    _internal_set_bc_optimization(from._internal_bc_optimization());
+  if (from._internal_bc_optimization() != 0) {
+    _this->_internal_set_bc_optimization(from._internal_bc_optimization());
   }
-  if (from.cc_optimization() != 0) {
-    _internal_set_cc_optimization(from._internal_cc_optimization());
+  if (from._internal_cc_optimization() != 0) {
+    _this->_internal_set_cc_optimization(from._internal_cc_optimization());
   }
-}
-
-void CompileRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:rsh.server.protocol.CompileRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void CompileRequest::CopyFrom(const CompileRequest& from) {
@@ -1154,167 +1136,201 @@ bool CompileRequest::IsInitialized() const {
 
 void CompileRequest::InternalSwap(CompileRequest* other) {
   using std::swap;
-  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  closure_.Swap(&other->closure_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.closure_, lhs_arena,
+      &other->_impl_.closure_, rhs_arena
+  );
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(CompileRequest, cc_optimization_)
-      + sizeof(CompileRequest::cc_optimization_)
-      - PROTOBUF_FIELD_OFFSET(CompileRequest, bc_optimization_)>(
-          reinterpret_cast<char*>(&bc_optimization_),
-          reinterpret_cast<char*>(&other->bc_optimization_));
+      PROTOBUF_FIELD_OFFSET(CompileRequest, _impl_.cc_optimization_)
+      + sizeof(CompileRequest::_impl_.cc_optimization_)
+      - PROTOBUF_FIELD_OFFSET(CompileRequest, _impl_.bc_optimization_)>(
+          reinterpret_cast<char*>(&_impl_.bc_optimization_),
+          reinterpret_cast<char*>(&other->_impl_.bc_optimization_));
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata CompileRequest::GetMetadata() const {
-  return GetMetadataStatic();
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
+      file_level_metadata_protocol_2eproto[2]);
 }
 
-
 // ===================================================================
 
-void CompiledFunction::InitAsDefaultInstance() {
-}
 class CompiledFunction::_Internal {
  public:
 };
 
-CompiledFunction::CompiledFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
+CompiledFunction::CompiledFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
   // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.CompiledFunction)
 }
 CompiledFunction::CompiledFunction(const CompiledFunction& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CompiledFunction* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.name_){}
+    , decltype(_impl_.native_code_){}
+    , decltype(_impl_.constants_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_name().empty()) {
-    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
-      GetArena());
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
   }
-  native_code_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.native_code_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.native_code_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_native_code().empty()) {
-    native_code_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_native_code(),
-      GetArena());
+    _this->_impl_.native_code_.Set(from._internal_native_code(), 
+      _this->GetArenaForAllocation());
   }
-  constants_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _impl_.constants_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.constants_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   if (!from._internal_constants().empty()) {
-    constants_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_constants(),
-      GetArena());
+    _this->_impl_.constants_.Set(from._internal_constants(), 
+      _this->GetArenaForAllocation());
   }
   // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.CompiledFunction)
 }
 
-void CompiledFunction::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompiledFunction_protocol_2eproto.base);
-  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  native_code_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  constants_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline void CompiledFunction::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.name_){}
+    , decltype(_impl_.native_code_){}
+    , decltype(_impl_.constants_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.native_code_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.native_code_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.constants_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.constants_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
 CompiledFunction::~CompiledFunction() {
   // @@protoc_insertion_point(destructor:rsh.server.protocol.CompiledFunction)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
   SharedDtor();
-  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void CompiledFunction::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
-  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  native_code_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  constants_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline void CompiledFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.native_code_.Destroy();
+  _impl_.constants_.Destroy();
 }
 
-void CompiledFunction::ArenaDtor(void* object) {
-  CompiledFunction* _this = reinterpret_cast< CompiledFunction* >(object);
-  (void)_this;
-}
-void CompiledFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
 void CompiledFunction::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const CompiledFunction& CompiledFunction::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompiledFunction_protocol_2eproto.base);
-  return *internal_default_instance();
+  _impl_._cached_size_.Set(size);
 }
 
-
 void CompiledFunction::Clear() {
 // @@protoc_insertion_point(message_clear_start:rsh.server.protocol.CompiledFunction)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  native_code_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  constants_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.name_.ClearToEmpty();
+  _impl_.native_code_.ClearToEmpty();
+  _impl_.constants_.ClearToEmpty();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* CompiledFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* CompiledFunction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
   while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
       // string name = 2;
       case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           auto str = _internal_mutable_name();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.CompiledFunction.name"));
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.CompiledFunction.name"));
+        } else
+          goto handle_unusual;
         continue;
       // bytes native_code = 3;
       case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
           auto str = _internal_mutable_native_code();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+        } else
+          goto handle_unusual;
         continue;
       // bytes constants = 4;
       case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
           auto str = _internal_mutable_constants();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
+        } else
+          goto handle_unusual;
         continue;
-      }
+      default:
+        goto handle_unusual;
     }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
   }  // while
-success:
+message_done:
   return ptr;
 failure:
   ptr = nullptr;
-  goto success;
+  goto message_done;
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* CompiledFunction::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+uint8_t* CompiledFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.CompiledFunction)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   // string name = 2;
-  if (this->name().size() > 0) {
+  if (!this->_internal_name().empty()) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
@@ -1324,19 +1340,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* CompiledFunction::_InternalSerialize(
   }
 
   // bytes native_code = 3;
-  if (this->native_code().size() > 0) {
+  if (!this->_internal_native_code().empty()) {
     target = stream->WriteBytesMaybeAliased(
         3, this->_internal_native_code(), target);
   }
 
   // bytes constants = 4;
-  if (this->constants().size() > 0) {
+  if (!this->_internal_constants().empty()) {
     target = stream->WriteBytesMaybeAliased(
         4, this->_internal_constants(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.CompiledFunction)
@@ -1347,78 +1363,59 @@ size_t CompiledFunction::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.CompiledFunction)
   size_t total_size = 0;
 
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
   // string name = 2;
-  if (this->name().size() > 0) {
+  if (!this->_internal_name().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
         this->_internal_name());
   }
 
   // bytes native_code = 3;
-  if (this->native_code().size() > 0) {
+  if (!this->_internal_native_code().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
         this->_internal_native_code());
   }
 
   // bytes constants = 4;
-  if (this->constants().size() > 0) {
+  if (!this->_internal_constants().empty()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
         this->_internal_constants());
   }
 
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
-        _internal_metadata_, total_size, &_cached_size_);
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-void CompiledFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:rsh.server.protocol.CompiledFunction)
-  GOOGLE_DCHECK_NE(&from, this);
-  const CompiledFunction* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CompiledFunction>(
-          &from);
-  if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rsh.server.protocol.CompiledFunction)
-    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:rsh.server.protocol.CompiledFunction)
-    MergeFrom(*source);
-  }
-}
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompiledFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CompiledFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompiledFunction::GetClassData() const { return &_class_data_; }
 
-void CompiledFunction::MergeFrom(const CompiledFunction& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompiledFunction)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+
+void CompiledFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CompiledFunction*>(&to_msg);
+  auto& from = static_cast<const CompiledFunction&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompiledFunction)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.name().size() > 0) {
-    _internal_set_name(from._internal_name());
+  if (!from._internal_name().empty()) {
+    _this->_internal_set_name(from._internal_name());
   }
-  if (from.native_code().size() > 0) {
-    _internal_set_native_code(from._internal_native_code());
+  if (!from._internal_native_code().empty()) {
+    _this->_internal_set_native_code(from._internal_native_code());
   }
-  if (from.constants().size() > 0) {
-    _internal_set_constants(from._internal_constants());
+  if (!from._internal_constants().empty()) {
+    _this->_internal_set_constants(from._internal_constants());
   }
-}
-
-void CompiledFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:rsh.server.protocol.CompiledFunction)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void CompiledFunction::CopyFrom(const CompiledFunction& from) {
@@ -1434,25 +1431,31 @@ bool CompiledFunction::IsInitialized() const {
 
 void CompiledFunction::InternalSwap(CompiledFunction* other) {
   using std::swap;
-  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  native_code_.Swap(&other->native_code_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  constants_.Swap(&other->constants_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.native_code_, lhs_arena,
+      &other->_impl_.native_code_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.constants_, lhs_arena,
+      &other->_impl_.constants_, rhs_arena
+  );
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata CompiledFunction::GetMetadata() const {
-  return GetMetadataStatic();
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
+      file_level_metadata_protocol_2eproto[3]);
 }
 
-
 // ===================================================================
 
-void CompileResponse::InitAsDefaultInstance() {
-  ::rsh::server::protocol::_CompileResponse_default_instance_.failure_.UnsafeSetDefault(
-      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  ::rsh::server::protocol::_CompileResponse_default_instance_.result_ = const_cast< ::rsh::server::protocol::CompiledFunction*>(
-      ::rsh::server::protocol::CompiledFunction::internal_default_instance());
-}
 class CompileResponse::_Internal {
  public:
   static const ::rsh::server::protocol::CompiledFunction& result(const CompileResponse* msg);
@@ -1460,40 +1463,47 @@ class CompileResponse::_Internal {
 
 const ::rsh::server::protocol::CompiledFunction&
 CompileResponse::_Internal::result(const CompileResponse* msg) {
-  return *msg->data_.result_;
+  return *msg->_impl_.data_.result_;
 }
 void CompileResponse::set_allocated_result(::rsh::server::protocol::CompiledFunction* result) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   clear_data();
   if (result) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(result);
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(result);
     if (message_arena != submessage_arena) {
       result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, result, submessage_arena);
     }
     set_has_result();
-    data_.result_ = result;
+    _impl_.data_.result_ = result;
   }
   // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileResponse.result)
 }
-CompileResponse::CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
-  SharedCtor();
-  RegisterArenaDtor(arena);
+CompileResponse::CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
   // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.CompileResponse)
 }
 CompileResponse::CompileResponse(const CompileResponse& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CompileResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.data_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   clear_has_data();
   switch (from.data_case()) {
     case kFailure: {
-      _internal_set_failure(from._internal_failure());
+      _this->_internal_set_failure(from._internal_failure());
       break;
     }
     case kResult: {
-      _internal_mutable_result()->::rsh::server::protocol::CompiledFunction::MergeFrom(from._internal_result());
+      _this->_internal_mutable_result()->::rsh::server::protocol::CompiledFunction::MergeFrom(
+          from._internal_result());
       break;
     }
     case DATA_NOT_SET: {
@@ -1503,49 +1513,48 @@ CompileResponse::CompileResponse(const CompileResponse& from)
   // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.CompileResponse)
 }
 
-void CompileResponse::SharedCtor() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompileResponse_protocol_2eproto.base);
+inline void CompileResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.data_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
   clear_has_data();
 }
 
 CompileResponse::~CompileResponse() {
   // @@protoc_insertion_point(destructor:rsh.server.protocol.CompileResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
   SharedDtor();
-  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-void CompileResponse::SharedDtor() {
-  GOOGLE_DCHECK(GetArena() == nullptr);
+inline void CompileResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
   if (has_data()) {
     clear_data();
   }
 }
 
-void CompileResponse::ArenaDtor(void* object) {
-  CompileResponse* _this = reinterpret_cast< CompileResponse* >(object);
-  (void)_this;
-}
-void CompileResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
 void CompileResponse::SetCachedSize(int size) const {
-  _cached_size_.Set(size);
-}
-const CompileResponse& CompileResponse::default_instance() {
-  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompileResponse_protocol_2eproto.base);
-  return *internal_default_instance();
+  _impl_._cached_size_.Set(size);
 }
 
-
 void CompileResponse::clear_data() {
 // @@protoc_insertion_point(one_of_clear_start:rsh.server.protocol.CompileResponse)
   switch (data_case()) {
     case kFailure: {
-      data_.failure_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+      _impl_.data_.failure_.Destroy();
       break;
     }
     case kResult: {
-      if (GetArena() == nullptr) {
-        delete data_.result_;
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.data_.result_;
       }
       break;
     }
@@ -1553,13 +1562,13 @@ void CompileResponse::clear_data() {
       break;
     }
   }
-  _oneof_case_[0] = DATA_NOT_SET;
+  _impl_._oneof_case_[0] = DATA_NOT_SET;
 }
 
 
 void CompileResponse::Clear() {
 // @@protoc_insertion_point(message_clear_start:rsh.server.protocol.CompileResponse)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
@@ -1567,56 +1576,57 @@ void CompileResponse::Clear() {
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* CompileResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
   while (!ctx->Done(&ptr)) {
-    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
-    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
-    CHK_(ptr);
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
       // string failure = 2;
       case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           auto str = _internal_mutable_failure();
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "rsh.server.protocol.CompileResponse.failure"));
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-        } else goto handle_unusual;
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.CompileResponse.failure"));
+        } else
+          goto handle_unusual;
         continue;
       // .rsh.server.protocol.CompiledFunction result = 3;
       case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
           ptr = ctx->ParseMessage(_internal_mutable_result(), ptr);
           CHK_(ptr);
-        } else goto handle_unusual;
-        continue;
-      default: {
-      handle_unusual:
-        if ((tag & 7) == 4 || tag == 0) {
-          ctx->SetLastTag(tag);
-          goto success;
-        }
-        ptr = UnknownFieldParse(tag,
-            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-            ptr, ctx);
-        CHK_(ptr != nullptr);
+        } else
+          goto handle_unusual;
         continue;
-      }
+      default:
+        goto handle_unusual;
     }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
   }  // while
-success:
+message_done:
   return ptr;
 failure:
   ptr = nullptr;
-  goto success;
+  goto message_done;
 #undef CHK_
 }
 
-::PROTOBUF_NAMESPACE_ID::uint8* CompileResponse::_InternalSerialize(
-    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+uint8_t* CompileResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.CompileResponse)
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   // string failure = 2;
@@ -1631,14 +1641,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* CompileResponse::_InternalSerialize(
 
   // .rsh.server.protocol.CompiledFunction result = 3;
   if (_internal_has_result()) {
-    target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(
-        3, _Internal::result(this), target, stream);
+      InternalWriteMessage(3, _Internal::result(this),
+        _Internal::result(this).GetCachedSize(), target, stream);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.CompileResponse)
@@ -1649,7 +1658,7 @@ size_t CompileResponse::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.CompileResponse)
   size_t total_size = 0;
 
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
@@ -1665,64 +1674,46 @@ size_t CompileResponse::ByteSizeLong() const {
     case kResult: {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *data_.result_);
+          *_impl_.data_.result_);
       break;
     }
     case DATA_NOT_SET: {
       break;
     }
   }
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
-        _internal_metadata_, total_size, &_cached_size_);
-  }
-  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
-  SetCachedSize(cached_size);
-  return total_size;
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-void CompileResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:rsh.server.protocol.CompileResponse)
-  GOOGLE_DCHECK_NE(&from, this);
-  const CompileResponse* source =
-      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CompileResponse>(
-          &from);
-  if (source == nullptr) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rsh.server.protocol.CompileResponse)
-    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:rsh.server.protocol.CompileResponse)
-    MergeFrom(*source);
-  }
-}
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompileResponse::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CompileResponse::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileResponse::GetClassData() const { return &_class_data_; }
 
-void CompileResponse::MergeFrom(const CompileResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompileResponse)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+
+void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CompileResponse*>(&to_msg);
+  auto& from = static_cast<const CompileResponse&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompileResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   switch (from.data_case()) {
     case kFailure: {
-      _internal_set_failure(from._internal_failure());
+      _this->_internal_set_failure(from._internal_failure());
       break;
     }
     case kResult: {
-      _internal_mutable_result()->::rsh::server::protocol::CompiledFunction::MergeFrom(from._internal_result());
+      _this->_internal_mutable_result()->::rsh::server::protocol::CompiledFunction::MergeFrom(
+          from._internal_result());
       break;
     }
     case DATA_NOT_SET: {
       break;
     }
   }
-}
-
-void CompileResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:rsh.server.protocol.CompileResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void CompileResponse::CopyFrom(const CompileResponse& from) {
@@ -1738,34 +1729,40 @@ bool CompileResponse::IsInitialized() const {
 
 void CompileResponse::InternalSwap(CompileResponse* other) {
   using std::swap;
-  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
-  swap(data_, other->data_);
-  swap(_oneof_case_[0], other->_oneof_case_[0]);
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.data_, other->_impl_.data_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata CompileResponse::GetMetadata() const {
-  return GetMetadataStatic();
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
+      file_level_metadata_protocol_2eproto[4]);
 }
 
-
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace protocol
 }  // namespace server
 }  // namespace rsh
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::Request* Arena::CreateMaybeMessage< ::rsh::server::protocol::Request >(Arena* arena) {
+template<> PROTOBUF_NOINLINE ::rsh::server::protocol::Request*
+Arena::CreateMaybeMessage< ::rsh::server::protocol::Request >(Arena* arena) {
   return Arena::CreateMessageInternal< ::rsh::server::protocol::Request >(arena);
 }
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::HandshakeRequest* Arena::CreateMaybeMessage< ::rsh::server::protocol::HandshakeRequest >(Arena* arena) {
+template<> PROTOBUF_NOINLINE ::rsh::server::protocol::HandshakeRequest*
+Arena::CreateMaybeMessage< ::rsh::server::protocol::HandshakeRequest >(Arena* arena) {
   return Arena::CreateMessageInternal< ::rsh::server::protocol::HandshakeRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompileRequest* Arena::CreateMaybeMessage< ::rsh::server::protocol::CompileRequest >(Arena* arena) {
+template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompileRequest*
+Arena::CreateMaybeMessage< ::rsh::server::protocol::CompileRequest >(Arena* arena) {
   return Arena::CreateMessageInternal< ::rsh::server::protocol::CompileRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompiledFunction* Arena::CreateMaybeMessage< ::rsh::server::protocol::CompiledFunction >(Arena* arena) {
+template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompiledFunction*
+Arena::CreateMaybeMessage< ::rsh::server::protocol::CompiledFunction >(Arena* arena) {
   return Arena::CreateMessageInternal< ::rsh::server::protocol::CompiledFunction >(arena);
 }
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompileResponse* Arena::CreateMaybeMessage< ::rsh::server::protocol::CompileResponse >(Arena* arena) {
+template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompileResponse*
+Arena::CreateMaybeMessage< ::rsh::server::protocol::CompileResponse >(Arena* arena) {
   return Arena::CreateMessageInternal< ::rsh::server::protocol::CompileResponse >(arena);
 }
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/client/rsh/src/protocol.pb.h b/client/rsh/src/protocol.pb.h
index 7fb98bdf6..4c0c20f57 100644
--- a/client/rsh/src/protocol.pb.h
+++ b/client/rsh/src/protocol.pb.h
@@ -8,12 +8,12 @@
 #include <string>
 
 #include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3012000
+#if PROTOBUF_VERSION < 3021000
 #error This file was generated by a newer version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3012004 < PROTOBUF_MIN_PROTOC_VERSION
+#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.
@@ -23,9 +23,7 @@
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/arena.h>
 #include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_table_driven.h>
 #include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/inlined_string_field.h>
 #include <google/protobuf/metadata_lite.h>
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
@@ -43,34 +41,26 @@ PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
 struct TableStruct_protocol_2eproto {
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
-    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
-  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
-  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+  static const uint32_t offsets[];
 };
 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protocol_2eproto;
 namespace rsh {
 namespace server {
 namespace protocol {
 class CompileRequest;
-class CompileRequestDefaultTypeInternal;
+struct CompileRequestDefaultTypeInternal;
 extern CompileRequestDefaultTypeInternal _CompileRequest_default_instance_;
 class CompileResponse;
-class CompileResponseDefaultTypeInternal;
+struct CompileResponseDefaultTypeInternal;
 extern CompileResponseDefaultTypeInternal _CompileResponse_default_instance_;
 class CompiledFunction;
-class CompiledFunctionDefaultTypeInternal;
+struct CompiledFunctionDefaultTypeInternal;
 extern CompiledFunctionDefaultTypeInternal _CompiledFunction_default_instance_;
 class HandshakeRequest;
-class HandshakeRequestDefaultTypeInternal;
+struct HandshakeRequestDefaultTypeInternal;
 extern HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_;
 class Request;
-class RequestDefaultTypeInternal;
+struct RequestDefaultTypeInternal;
 extern RequestDefaultTypeInternal _Request_default_instance_;
 }  // namespace protocol
 }  // namespace server
@@ -88,11 +78,12 @@ namespace protocol {
 
 // ===================================================================
 
-class Request PROTOBUF_FINAL :
+class Request final :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.Request) */ {
  public:
-  inline Request() : Request(nullptr) {};
-  virtual ~Request();
+  inline Request() : Request(nullptr) {}
+  ~Request() override;
+  explicit PROTOBUF_CONSTEXPR Request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
   Request(const Request& from);
   Request(Request&& from) noexcept
@@ -105,8 +96,13 @@ class Request PROTOBUF_FINAL :
     return *this;
   }
   inline Request& operator=(Request&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
     } else {
       CopyFrom(from);
     }
@@ -117,20 +113,20 @@ class Request PROTOBUF_FINAL :
     return GetDescriptor();
   }
   static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return GetMetadataStatic().descriptor;
+    return default_instance().GetMetadata().descriptor;
   }
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return GetMetadataStatic().reflection;
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Request& default_instance() {
+    return *internal_default_instance();
   }
-  static const Request& default_instance();
-
   enum PayloadCase {
     kHandshake = 1,
     kCompile = 2,
     PAYLOAD_NOT_SET = 0,
   };
 
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
   static inline const Request* internal_default_instance() {
     return reinterpret_cast<const Request*>(
                &_Request_default_instance_);
@@ -143,7 +139,12 @@ class Request PROTOBUF_FINAL :
   }
   inline void Swap(Request* other) {
     if (other == this) return;
-    if (GetArena() == other->GetArena()) {
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
       InternalSwap(other);
     } else {
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
@@ -151,56 +152,53 @@ class Request PROTOBUF_FINAL :
   }
   void UnsafeArenaSwap(Request* other) {
     if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
-  inline Request* New() const final {
-    return CreateMaybeMessage<Request>(nullptr);
-  }
-
-  Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+  Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
     return CreateMaybeMessage<Request>(arena);
   }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
   void CopyFrom(const Request& from);
-  void MergeFrom(const Request& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Request& from) {
+    Request::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _cached_size_.Get(); }
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
   private:
-  inline void SharedCtor();
-  inline void SharedDtor();
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(Request* other);
+
+  private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
     return "rsh.server.protocol.Request";
   }
   protected:
-  explicit Request(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit Request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
   public:
 
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-  private:
-  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
-    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protocol_2eproto);
-    return ::descriptor_table_protocol_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
-  public:
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
   // nested types ----------------------------------------------------
 
@@ -217,7 +215,7 @@ class Request PROTOBUF_FINAL :
   public:
   void clear_handshake();
   const ::rsh::server::protocol::HandshakeRequest& handshake() const;
-  ::rsh::server::protocol::HandshakeRequest* release_handshake();
+  PROTOBUF_NODISCARD ::rsh::server::protocol::HandshakeRequest* release_handshake();
   ::rsh::server::protocol::HandshakeRequest* mutable_handshake();
   void set_allocated_handshake(::rsh::server::protocol::HandshakeRequest* handshake);
   private:
@@ -235,7 +233,7 @@ class Request PROTOBUF_FINAL :
   public:
   void clear_compile();
   const ::rsh::server::protocol::CompileRequest& compile() const;
-  ::rsh::server::protocol::CompileRequest* release_compile();
+  PROTOBUF_NODISCARD ::rsh::server::protocol::CompileRequest* release_compile();
   ::rsh::server::protocol::CompileRequest* mutable_compile();
   void set_allocated_compile(::rsh::server::protocol::CompileRequest* compile);
   private:
@@ -260,23 +258,28 @@ class Request PROTOBUF_FINAL :
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  union PayloadUnion {
-    PayloadUnion() {}
-    ::rsh::server::protocol::HandshakeRequest* handshake_;
-    ::rsh::server::protocol::CompileRequest* compile_;
-  } payload_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+  struct Impl_ {
+    union PayloadUnion {
+      constexpr PayloadUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::rsh::server::protocol::HandshakeRequest* handshake_;
+      ::rsh::server::protocol::CompileRequest* compile_;
+    } payload_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
 
+  };
+  union { Impl_ _impl_; };
   friend struct ::TableStruct_protocol_2eproto;
 };
 // -------------------------------------------------------------------
 
-class HandshakeRequest PROTOBUF_FINAL :
+class HandshakeRequest final :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.HandshakeRequest) */ {
  public:
-  inline HandshakeRequest() : HandshakeRequest(nullptr) {};
-  virtual ~HandshakeRequest();
+  inline HandshakeRequest() : HandshakeRequest(nullptr) {}
+  ~HandshakeRequest() override;
+  explicit PROTOBUF_CONSTEXPR HandshakeRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
   HandshakeRequest(const HandshakeRequest& from);
   HandshakeRequest(HandshakeRequest&& from) noexcept
@@ -289,8 +292,13 @@ class HandshakeRequest PROTOBUF_FINAL :
     return *this;
   }
   inline HandshakeRequest& operator=(HandshakeRequest&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
     } else {
       CopyFrom(from);
     }
@@ -301,14 +309,14 @@ class HandshakeRequest PROTOBUF_FINAL :
     return GetDescriptor();
   }
   static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return GetMetadataStatic().descriptor;
+    return default_instance().GetMetadata().descriptor;
   }
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return GetMetadataStatic().reflection;
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HandshakeRequest& default_instance() {
+    return *internal_default_instance();
   }
-  static const HandshakeRequest& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
   static inline const HandshakeRequest* internal_default_instance() {
     return reinterpret_cast<const HandshakeRequest*>(
                &_HandshakeRequest_default_instance_);
@@ -321,7 +329,12 @@ class HandshakeRequest PROTOBUF_FINAL :
   }
   inline void Swap(HandshakeRequest* other) {
     if (other == this) return;
-    if (GetArena() == other->GetArena()) {
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
       InternalSwap(other);
     } else {
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
@@ -329,56 +342,53 @@ class HandshakeRequest PROTOBUF_FINAL :
   }
   void UnsafeArenaSwap(HandshakeRequest* other) {
     if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
-  inline HandshakeRequest* New() const final {
-    return CreateMaybeMessage<HandshakeRequest>(nullptr);
-  }
-
-  HandshakeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+  HandshakeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
     return CreateMaybeMessage<HandshakeRequest>(arena);
   }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
   void CopyFrom(const HandshakeRequest& from);
-  void MergeFrom(const HandshakeRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HandshakeRequest& from) {
+    HandshakeRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _cached_size_.Get(); }
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
   private:
-  inline void SharedCtor();
-  inline void SharedDtor();
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(HandshakeRequest* other);
+
+  private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
     return "rsh.server.protocol.HandshakeRequest";
   }
   protected:
-  explicit HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
   public:
 
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-  private:
-  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
-    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protocol_2eproto);
-    return ::descriptor_table_protocol_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
-  public:
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
   // nested types ----------------------------------------------------
 
@@ -417,75 +427,42 @@ class HandshakeRequest PROTOBUF_FINAL :
   // string Rsh_version = 1;
   void clear_rsh_version();
   const std::string& rsh_version() const;
-  void set_rsh_version(const std::string& value);
-  void set_rsh_version(std::string&& value);
-  void set_rsh_version(const char* value);
-  void set_rsh_version(const char* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rsh_version(ArgT0&& arg0, ArgT... args);
   std::string* mutable_rsh_version();
-  std::string* release_rsh_version();
+  PROTOBUF_NODISCARD std::string* release_rsh_version();
   void set_allocated_rsh_version(std::string* rsh_version);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_rsh_version();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_rsh_version(
-      std::string* rsh_version);
   private:
   const std::string& _internal_rsh_version() const;
-  void _internal_set_rsh_version(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rsh_version(const std::string& value);
   std::string* _internal_mutable_rsh_version();
   public:
 
   // string R_version = 2;
   void clear_r_version();
   const std::string& r_version() const;
-  void set_r_version(const std::string& value);
-  void set_r_version(std::string&& value);
-  void set_r_version(const char* value);
-  void set_r_version(const char* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_r_version(ArgT0&& arg0, ArgT... args);
   std::string* mutable_r_version();
-  std::string* release_r_version();
+  PROTOBUF_NODISCARD std::string* release_r_version();
   void set_allocated_r_version(std::string* r_version);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_r_version();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_r_version(
-      std::string* r_version);
   private:
   const std::string& _internal_r_version() const;
-  void _internal_set_r_version(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_r_version(const std::string& value);
   std::string* _internal_mutable_r_version();
   public:
 
   // string platform = 3;
   void clear_platform();
   const std::string& platform() const;
-  void set_platform(const std::string& value);
-  void set_platform(std::string&& value);
-  void set_platform(const char* value);
-  void set_platform(const char* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform(ArgT0&& arg0, ArgT... args);
   std::string* mutable_platform();
-  std::string* release_platform();
+  PROTOBUF_NODISCARD std::string* release_platform();
   void set_allocated_platform(std::string* platform);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_platform();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_platform(
-      std::string* platform);
   private:
   const std::string& _internal_platform() const;
-  void _internal_set_platform(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
   std::string* _internal_mutable_platform();
   public:
 
@@ -496,20 +473,24 @@ class HandshakeRequest PROTOBUF_FINAL :
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> packages_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rsh_version_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr r_version_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> packages_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rsh_version_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr r_version_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
   friend struct ::TableStruct_protocol_2eproto;
 };
 // -------------------------------------------------------------------
 
-class CompileRequest PROTOBUF_FINAL :
+class CompileRequest final :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.CompileRequest) */ {
  public:
-  inline CompileRequest() : CompileRequest(nullptr) {};
-  virtual ~CompileRequest();
+  inline CompileRequest() : CompileRequest(nullptr) {}
+  ~CompileRequest() override;
+  explicit PROTOBUF_CONSTEXPR CompileRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
   CompileRequest(const CompileRequest& from);
   CompileRequest(CompileRequest&& from) noexcept
@@ -522,8 +503,13 @@ class CompileRequest PROTOBUF_FINAL :
     return *this;
   }
   inline CompileRequest& operator=(CompileRequest&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
     } else {
       CopyFrom(from);
     }
@@ -534,14 +520,14 @@ class CompileRequest PROTOBUF_FINAL :
     return GetDescriptor();
   }
   static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return GetMetadataStatic().descriptor;
+    return default_instance().GetMetadata().descriptor;
   }
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return GetMetadataStatic().reflection;
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompileRequest& default_instance() {
+    return *internal_default_instance();
   }
-  static const CompileRequest& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
   static inline const CompileRequest* internal_default_instance() {
     return reinterpret_cast<const CompileRequest*>(
                &_CompileRequest_default_instance_);
@@ -554,7 +540,12 @@ class CompileRequest PROTOBUF_FINAL :
   }
   inline void Swap(CompileRequest* other) {
     if (other == this) return;
-    if (GetArena() == other->GetArena()) {
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
       InternalSwap(other);
     } else {
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
@@ -562,56 +553,53 @@ class CompileRequest PROTOBUF_FINAL :
   }
   void UnsafeArenaSwap(CompileRequest* other) {
     if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
-  inline CompileRequest* New() const final {
-    return CreateMaybeMessage<CompileRequest>(nullptr);
-  }
-
-  CompileRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+  CompileRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
     return CreateMaybeMessage<CompileRequest>(arena);
   }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
   void CopyFrom(const CompileRequest& from);
-  void MergeFrom(const CompileRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompileRequest& from) {
+    CompileRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _cached_size_.Get(); }
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
   private:
-  inline void SharedCtor();
-  inline void SharedDtor();
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(CompileRequest* other);
+
+  private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
     return "rsh.server.protocol.CompileRequest";
   }
   protected:
-  explicit CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
   public:
 
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-  private:
-  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
-    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protocol_2eproto);
-    return ::descriptor_table_protocol_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
-  public:
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
   // nested types ----------------------------------------------------
 
@@ -626,69 +614,47 @@ class CompileRequest PROTOBUF_FINAL :
   // string name = 2;
   void clear_name();
   const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
   std::string* mutable_name();
-  std::string* release_name();
+  PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
   private:
   const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
   std::string* _internal_mutable_name();
   public:
 
   // bytes closure = 3;
   void clear_closure();
   const std::string& closure() const;
-  void set_closure(const std::string& value);
-  void set_closure(std::string&& value);
-  void set_closure(const char* value);
-  void set_closure(const void* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_closure(ArgT0&& arg0, ArgT... args);
   std::string* mutable_closure();
-  std::string* release_closure();
+  PROTOBUF_NODISCARD std::string* release_closure();
   void set_allocated_closure(std::string* closure);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_closure();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_closure(
-      std::string* closure);
   private:
   const std::string& _internal_closure() const;
-  void _internal_set_closure(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_closure(const std::string& value);
   std::string* _internal_mutable_closure();
   public:
 
   // uint32 bc_optimization = 4;
   void clear_bc_optimization();
-  ::PROTOBUF_NAMESPACE_ID::uint32 bc_optimization() const;
-  void set_bc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  uint32_t bc_optimization() const;
+  void set_bc_optimization(uint32_t value);
   private:
-  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_bc_optimization() const;
-  void _internal_set_bc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  uint32_t _internal_bc_optimization() const;
+  void _internal_set_bc_optimization(uint32_t value);
   public:
 
   // uint32 cc_optimization = 5;
   void clear_cc_optimization();
-  ::PROTOBUF_NAMESPACE_ID::uint32 cc_optimization() const;
-  void set_cc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  uint32_t cc_optimization() const;
+  void set_cc_optimization(uint32_t value);
   private:
-  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_cc_optimization() const;
-  void _internal_set_cc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  uint32_t _internal_cc_optimization() const;
+  void _internal_set_cc_optimization(uint32_t value);
   public:
 
   // @@protoc_insertion_point(class_scope:rsh.server.protocol.CompileRequest)
@@ -698,20 +664,24 @@ class CompileRequest PROTOBUF_FINAL :
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr closure_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 bc_optimization_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 cc_optimization_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr closure_;
+    uint32_t bc_optimization_;
+    uint32_t cc_optimization_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
   friend struct ::TableStruct_protocol_2eproto;
 };
 // -------------------------------------------------------------------
 
-class CompiledFunction PROTOBUF_FINAL :
+class CompiledFunction final :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.CompiledFunction) */ {
  public:
-  inline CompiledFunction() : CompiledFunction(nullptr) {};
-  virtual ~CompiledFunction();
+  inline CompiledFunction() : CompiledFunction(nullptr) {}
+  ~CompiledFunction() override;
+  explicit PROTOBUF_CONSTEXPR CompiledFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
   CompiledFunction(const CompiledFunction& from);
   CompiledFunction(CompiledFunction&& from) noexcept
@@ -724,8 +694,13 @@ class CompiledFunction PROTOBUF_FINAL :
     return *this;
   }
   inline CompiledFunction& operator=(CompiledFunction&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
     } else {
       CopyFrom(from);
     }
@@ -736,14 +711,14 @@ class CompiledFunction PROTOBUF_FINAL :
     return GetDescriptor();
   }
   static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return GetMetadataStatic().descriptor;
+    return default_instance().GetMetadata().descriptor;
   }
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return GetMetadataStatic().reflection;
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompiledFunction& default_instance() {
+    return *internal_default_instance();
   }
-  static const CompiledFunction& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
   static inline const CompiledFunction* internal_default_instance() {
     return reinterpret_cast<const CompiledFunction*>(
                &_CompiledFunction_default_instance_);
@@ -756,7 +731,12 @@ class CompiledFunction PROTOBUF_FINAL :
   }
   inline void Swap(CompiledFunction* other) {
     if (other == this) return;
-    if (GetArena() == other->GetArena()) {
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
       InternalSwap(other);
     } else {
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
@@ -764,56 +744,53 @@ class CompiledFunction PROTOBUF_FINAL :
   }
   void UnsafeArenaSwap(CompiledFunction* other) {
     if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
-  inline CompiledFunction* New() const final {
-    return CreateMaybeMessage<CompiledFunction>(nullptr);
-  }
-
-  CompiledFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+  CompiledFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
     return CreateMaybeMessage<CompiledFunction>(arena);
   }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
   void CopyFrom(const CompiledFunction& from);
-  void MergeFrom(const CompiledFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompiledFunction& from) {
+    CompiledFunction::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _cached_size_.Get(); }
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
   private:
-  inline void SharedCtor();
-  inline void SharedDtor();
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(CompiledFunction* other);
+
+  private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
     return "rsh.server.protocol.CompiledFunction";
   }
   protected:
-  explicit CompiledFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CompiledFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
   public:
 
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-  private:
-  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
-    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protocol_2eproto);
-    return ::descriptor_table_protocol_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
-  public:
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
   // nested types ----------------------------------------------------
 
@@ -827,75 +804,42 @@ class CompiledFunction PROTOBUF_FINAL :
   // string name = 2;
   void clear_name();
   const std::string& name() const;
-  void set_name(const std::string& value);
-  void set_name(std::string&& value);
-  void set_name(const char* value);
-  void set_name(const char* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
   std::string* mutable_name();
-  std::string* release_name();
+  PROTOBUF_NODISCARD std::string* release_name();
   void set_allocated_name(std::string* name);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_name();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_name(
-      std::string* name);
   private:
   const std::string& _internal_name() const;
-  void _internal_set_name(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
   std::string* _internal_mutable_name();
   public:
 
   // bytes native_code = 3;
   void clear_native_code();
   const std::string& native_code() const;
-  void set_native_code(const std::string& value);
-  void set_native_code(std::string&& value);
-  void set_native_code(const char* value);
-  void set_native_code(const void* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_native_code(ArgT0&& arg0, ArgT... args);
   std::string* mutable_native_code();
-  std::string* release_native_code();
+  PROTOBUF_NODISCARD std::string* release_native_code();
   void set_allocated_native_code(std::string* native_code);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_native_code();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_native_code(
-      std::string* native_code);
   private:
   const std::string& _internal_native_code() const;
-  void _internal_set_native_code(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_native_code(const std::string& value);
   std::string* _internal_mutable_native_code();
   public:
 
   // bytes constants = 4;
   void clear_constants();
   const std::string& constants() const;
-  void set_constants(const std::string& value);
-  void set_constants(std::string&& value);
-  void set_constants(const char* value);
-  void set_constants(const void* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_constants(ArgT0&& arg0, ArgT... args);
   std::string* mutable_constants();
-  std::string* release_constants();
+  PROTOBUF_NODISCARD std::string* release_constants();
   void set_allocated_constants(std::string* constants);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_constants();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_constants(
-      std::string* constants);
   private:
   const std::string& _internal_constants() const;
-  void _internal_set_constants(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_constants(const std::string& value);
   std::string* _internal_mutable_constants();
   public:
 
@@ -906,19 +850,23 @@ class CompiledFunction PROTOBUF_FINAL :
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr native_code_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constants_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr native_code_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constants_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
   friend struct ::TableStruct_protocol_2eproto;
 };
 // -------------------------------------------------------------------
 
-class CompileResponse PROTOBUF_FINAL :
+class CompileResponse final :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.CompileResponse) */ {
  public:
-  inline CompileResponse() : CompileResponse(nullptr) {};
-  virtual ~CompileResponse();
+  inline CompileResponse() : CompileResponse(nullptr) {}
+  ~CompileResponse() override;
+  explicit PROTOBUF_CONSTEXPR CompileResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
   CompileResponse(const CompileResponse& from);
   CompileResponse(CompileResponse&& from) noexcept
@@ -931,8 +879,13 @@ class CompileResponse PROTOBUF_FINAL :
     return *this;
   }
   inline CompileResponse& operator=(CompileResponse&& from) noexcept {
-    if (GetArena() == from.GetArena()) {
-      if (this != &from) InternalSwap(&from);
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
     } else {
       CopyFrom(from);
     }
@@ -943,20 +896,20 @@ class CompileResponse PROTOBUF_FINAL :
     return GetDescriptor();
   }
   static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return GetMetadataStatic().descriptor;
+    return default_instance().GetMetadata().descriptor;
   }
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return GetMetadataStatic().reflection;
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompileResponse& default_instance() {
+    return *internal_default_instance();
   }
-  static const CompileResponse& default_instance();
-
   enum DataCase {
     kFailure = 2,
     kResult = 3,
     DATA_NOT_SET = 0,
   };
 
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
   static inline const CompileResponse* internal_default_instance() {
     return reinterpret_cast<const CompileResponse*>(
                &_CompileResponse_default_instance_);
@@ -969,7 +922,12 @@ class CompileResponse PROTOBUF_FINAL :
   }
   inline void Swap(CompileResponse* other) {
     if (other == this) return;
-    if (GetArena() == other->GetArena()) {
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
       InternalSwap(other);
     } else {
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
@@ -977,56 +935,53 @@ class CompileResponse PROTOBUF_FINAL :
   }
   void UnsafeArenaSwap(CompileResponse* other) {
     if (other == this) return;
-    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
   }
 
   // implements Message ----------------------------------------------
 
-  inline CompileResponse* New() const final {
-    return CreateMaybeMessage<CompileResponse>(nullptr);
-  }
-
-  CompileResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+  CompileResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
     return CreateMaybeMessage<CompileResponse>(arena);
   }
-  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
-  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
   void CopyFrom(const CompileResponse& from);
-  void MergeFrom(const CompileResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompileResponse& from) {
+    CompileResponse::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
-      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _cached_size_.Get(); }
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
   private:
-  inline void SharedCtor();
-  inline void SharedDtor();
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(CompileResponse* other);
+
+  private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
     return "rsh.server.protocol.CompileResponse";
   }
   protected:
-  explicit CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  private:
-  static void ArenaDtor(void* object);
-  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
   public:
 
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-  private:
-  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
-    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_protocol_2eproto);
-    return ::descriptor_table_protocol_2eproto.file_level_metadata[kIndexInFileMessages];
-  }
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
-  public:
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
   // nested types ----------------------------------------------------
 
@@ -1037,30 +992,20 @@ class CompileResponse PROTOBUF_FINAL :
     kResultFieldNumber = 3,
   };
   // string failure = 2;
+  bool has_failure() const;
   private:
   bool _internal_has_failure() const;
   public:
   void clear_failure();
   const std::string& failure() const;
-  void set_failure(const std::string& value);
-  void set_failure(std::string&& value);
-  void set_failure(const char* value);
-  void set_failure(const char* value, size_t size);
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_failure(ArgT0&& arg0, ArgT... args);
   std::string* mutable_failure();
-  std::string* release_failure();
+  PROTOBUF_NODISCARD std::string* release_failure();
   void set_allocated_failure(std::string* failure);
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  std::string* unsafe_arena_release_failure();
-  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
-  "    string fields are deprecated and will be removed in a"
-  "    future release.")
-  void unsafe_arena_set_allocated_failure(
-      std::string* failure);
   private:
   const std::string& _internal_failure() const;
-  void _internal_set_failure(const std::string& value);
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_failure(const std::string& value);
   std::string* _internal_mutable_failure();
   public:
 
@@ -1071,7 +1016,7 @@ class CompileResponse PROTOBUF_FINAL :
   public:
   void clear_result();
   const ::rsh::server::protocol::CompiledFunction& result() const;
-  ::rsh::server::protocol::CompiledFunction* release_result();
+  PROTOBUF_NODISCARD ::rsh::server::protocol::CompiledFunction* release_result();
   ::rsh::server::protocol::CompiledFunction* mutable_result();
   void set_allocated_result(::rsh::server::protocol::CompiledFunction* result);
   private:
@@ -1096,14 +1041,18 @@ class CompileResponse PROTOBUF_FINAL :
   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
-  union DataUnion {
-    DataUnion() {}
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr failure_;
-    ::rsh::server::protocol::CompiledFunction* result_;
-  } data_;
-  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+  struct Impl_ {
+    union DataUnion {
+      constexpr DataUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr failure_;
+      ::rsh::server::protocol::CompiledFunction* result_;
+    } data_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
 
+  };
+  union { Impl_ _impl_; };
   friend struct ::TableStruct_protocol_2eproto;
 };
 // ===================================================================
@@ -1125,12 +1074,12 @@ inline bool Request::has_handshake() const {
   return _internal_has_handshake();
 }
 inline void Request::set_has_handshake() {
-  _oneof_case_[0] = kHandshake;
+  _impl_._oneof_case_[0] = kHandshake;
 }
 inline void Request::clear_handshake() {
   if (_internal_has_handshake()) {
-    if (GetArena() == nullptr) {
-      delete payload_.handshake_;
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.payload_.handshake_;
     }
     clear_has_payload();
   }
@@ -1139,11 +1088,11 @@ inline ::rsh::server::protocol::HandshakeRequest* Request::release_handshake() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.Request.handshake)
   if (_internal_has_handshake()) {
     clear_has_payload();
-      ::rsh::server::protocol::HandshakeRequest* temp = payload_.handshake_;
-    if (GetArena() != nullptr) {
+    ::rsh::server::protocol::HandshakeRequest* temp = _impl_.payload_.handshake_;
+    if (GetArenaForAllocation() != nullptr) {
       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
     }
-    payload_.handshake_ = nullptr;
+    _impl_.payload_.handshake_ = nullptr;
     return temp;
   } else {
     return nullptr;
@@ -1151,8 +1100,8 @@ inline ::rsh::server::protocol::HandshakeRequest* Request::release_handshake() {
 }
 inline const ::rsh::server::protocol::HandshakeRequest& Request::_internal_handshake() const {
   return _internal_has_handshake()
-      ? *payload_.handshake_
-      : *reinterpret_cast< ::rsh::server::protocol::HandshakeRequest*>(&::rsh::server::protocol::_HandshakeRequest_default_instance_);
+      ? *_impl_.payload_.handshake_
+      : reinterpret_cast< ::rsh::server::protocol::HandshakeRequest&>(::rsh::server::protocol::_HandshakeRequest_default_instance_);
 }
 inline const ::rsh::server::protocol::HandshakeRequest& Request::handshake() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.Request.handshake)
@@ -1162,8 +1111,8 @@ inline ::rsh::server::protocol::HandshakeRequest* Request::unsafe_arena_release_
   // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.Request.handshake)
   if (_internal_has_handshake()) {
     clear_has_payload();
-    ::rsh::server::protocol::HandshakeRequest* temp = payload_.handshake_;
-    payload_.handshake_ = nullptr;
+    ::rsh::server::protocol::HandshakeRequest* temp = _impl_.payload_.handshake_;
+    _impl_.payload_.handshake_ = nullptr;
     return temp;
   } else {
     return nullptr;
@@ -1173,7 +1122,7 @@ inline void Request::unsafe_arena_set_allocated_handshake(::rsh::server::protoco
   clear_payload();
   if (handshake) {
     set_has_handshake();
-    payload_.handshake_ = handshake;
+    _impl_.payload_.handshake_ = handshake;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.Request.handshake)
 }
@@ -1181,13 +1130,14 @@ inline ::rsh::server::protocol::HandshakeRequest* Request::_internal_mutable_han
   if (!_internal_has_handshake()) {
     clear_payload();
     set_has_handshake();
-    payload_.handshake_ = CreateMaybeMessage< ::rsh::server::protocol::HandshakeRequest >(GetArena());
+    _impl_.payload_.handshake_ = CreateMaybeMessage< ::rsh::server::protocol::HandshakeRequest >(GetArenaForAllocation());
   }
-  return payload_.handshake_;
+  return _impl_.payload_.handshake_;
 }
 inline ::rsh::server::protocol::HandshakeRequest* Request::mutable_handshake() {
+  ::rsh::server::protocol::HandshakeRequest* _msg = _internal_mutable_handshake();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.Request.handshake)
-  return _internal_mutable_handshake();
+  return _msg;
 }
 
 // .rsh.server.protocol.CompileRequest compile = 2;
@@ -1198,12 +1148,12 @@ inline bool Request::has_compile() const {
   return _internal_has_compile();
 }
 inline void Request::set_has_compile() {
-  _oneof_case_[0] = kCompile;
+  _impl_._oneof_case_[0] = kCompile;
 }
 inline void Request::clear_compile() {
   if (_internal_has_compile()) {
-    if (GetArena() == nullptr) {
-      delete payload_.compile_;
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.payload_.compile_;
     }
     clear_has_payload();
   }
@@ -1212,11 +1162,11 @@ inline ::rsh::server::protocol::CompileRequest* Request::release_compile() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.Request.compile)
   if (_internal_has_compile()) {
     clear_has_payload();
-      ::rsh::server::protocol::CompileRequest* temp = payload_.compile_;
-    if (GetArena() != nullptr) {
+    ::rsh::server::protocol::CompileRequest* temp = _impl_.payload_.compile_;
+    if (GetArenaForAllocation() != nullptr) {
       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
     }
-    payload_.compile_ = nullptr;
+    _impl_.payload_.compile_ = nullptr;
     return temp;
   } else {
     return nullptr;
@@ -1224,8 +1174,8 @@ inline ::rsh::server::protocol::CompileRequest* Request::release_compile() {
 }
 inline const ::rsh::server::protocol::CompileRequest& Request::_internal_compile() const {
   return _internal_has_compile()
-      ? *payload_.compile_
-      : *reinterpret_cast< ::rsh::server::protocol::CompileRequest*>(&::rsh::server::protocol::_CompileRequest_default_instance_);
+      ? *_impl_.payload_.compile_
+      : reinterpret_cast< ::rsh::server::protocol::CompileRequest&>(::rsh::server::protocol::_CompileRequest_default_instance_);
 }
 inline const ::rsh::server::protocol::CompileRequest& Request::compile() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.Request.compile)
@@ -1235,8 +1185,8 @@ inline ::rsh::server::protocol::CompileRequest* Request::unsafe_arena_release_co
   // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.Request.compile)
   if (_internal_has_compile()) {
     clear_has_payload();
-    ::rsh::server::protocol::CompileRequest* temp = payload_.compile_;
-    payload_.compile_ = nullptr;
+    ::rsh::server::protocol::CompileRequest* temp = _impl_.payload_.compile_;
+    _impl_.payload_.compile_ = nullptr;
     return temp;
   } else {
     return nullptr;
@@ -1246,7 +1196,7 @@ inline void Request::unsafe_arena_set_allocated_compile(::rsh::server::protocol:
   clear_payload();
   if (compile) {
     set_has_compile();
-    payload_.compile_ = compile;
+    _impl_.payload_.compile_ = compile;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.Request.compile)
 }
@@ -1254,23 +1204,24 @@ inline ::rsh::server::protocol::CompileRequest* Request::_internal_mutable_compi
   if (!_internal_has_compile()) {
     clear_payload();
     set_has_compile();
-    payload_.compile_ = CreateMaybeMessage< ::rsh::server::protocol::CompileRequest >(GetArena());
+    _impl_.payload_.compile_ = CreateMaybeMessage< ::rsh::server::protocol::CompileRequest >(GetArenaForAllocation());
   }
-  return payload_.compile_;
+  return _impl_.payload_.compile_;
 }
 inline ::rsh::server::protocol::CompileRequest* Request::mutable_compile() {
+  ::rsh::server::protocol::CompileRequest* _msg = _internal_mutable_compile();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.Request.compile)
-  return _internal_mutable_compile();
+  return _msg;
 }
 
 inline bool Request::has_payload() const {
   return payload_case() != PAYLOAD_NOT_SET;
 }
 inline void Request::clear_has_payload() {
-  _oneof_case_[0] = PAYLOAD_NOT_SET;
+  _impl_._oneof_case_[0] = PAYLOAD_NOT_SET;
 }
 inline Request::PayloadCase Request::payload_case() const {
-  return Request::PayloadCase(_oneof_case_[0]);
+  return Request::PayloadCase(_impl_._oneof_case_[0]);
 }
 // -------------------------------------------------------------------
 
@@ -1278,54 +1229,38 @@ inline Request::PayloadCase Request::payload_case() const {
 
 // string Rsh_version = 1;
 inline void HandshakeRequest::clear_rsh_version() {
-  rsh_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.rsh_version_.ClearToEmpty();
 }
 inline const std::string& HandshakeRequest::rsh_version() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.Rsh_version)
   return _internal_rsh_version();
 }
-inline void HandshakeRequest::set_rsh_version(const std::string& value) {
-  _internal_set_rsh_version(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeRequest::set_rsh_version(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.rsh_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.Rsh_version)
 }
 inline std::string* HandshakeRequest::mutable_rsh_version() {
+  std::string* _s = _internal_mutable_rsh_version();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.Rsh_version)
-  return _internal_mutable_rsh_version();
+  return _s;
 }
 inline const std::string& HandshakeRequest::_internal_rsh_version() const {
-  return rsh_version_.Get();
+  return _impl_.rsh_version_.Get();
 }
 inline void HandshakeRequest::_internal_set_rsh_version(const std::string& value) {
   
-  rsh_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void HandshakeRequest::set_rsh_version(std::string&& value) {
-  
-  rsh_version_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.HandshakeRequest.Rsh_version)
-}
-inline void HandshakeRequest::set_rsh_version(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  rsh_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.HandshakeRequest.Rsh_version)
-}
-inline void HandshakeRequest::set_rsh_version(const char* value,
-    size_t size) {
-  
-  rsh_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.HandshakeRequest.Rsh_version)
+  _impl_.rsh_version_.Set(value, GetArenaForAllocation());
 }
 inline std::string* HandshakeRequest::_internal_mutable_rsh_version() {
   
-  return rsh_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.rsh_version_.Mutable(GetArenaForAllocation());
 }
 inline std::string* HandshakeRequest::release_rsh_version() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.HandshakeRequest.Rsh_version)
-  return rsh_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.rsh_version_.Release();
 }
 inline void HandshakeRequest::set_allocated_rsh_version(std::string* rsh_version) {
   if (rsh_version != nullptr) {
@@ -1333,80 +1268,49 @@ inline void HandshakeRequest::set_allocated_rsh_version(std::string* rsh_version
   } else {
     
   }
-  rsh_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rsh_version,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.Rsh_version)
-}
-inline std::string* HandshakeRequest::unsafe_arena_release_rsh_version() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.HandshakeRequest.Rsh_version)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return rsh_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void HandshakeRequest::unsafe_arena_set_allocated_rsh_version(
-    std::string* rsh_version) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (rsh_version != nullptr) {
-    
-  } else {
-    
+  _impl_.rsh_version_.SetAllocated(rsh_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rsh_version_.IsDefault()) {
+    _impl_.rsh_version_.Set("", GetArenaForAllocation());
   }
-  rsh_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      rsh_version, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.HandshakeRequest.Rsh_version)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.Rsh_version)
 }
 
 // string R_version = 2;
 inline void HandshakeRequest::clear_r_version() {
-  r_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.r_version_.ClearToEmpty();
 }
 inline const std::string& HandshakeRequest::r_version() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.R_version)
   return _internal_r_version();
 }
-inline void HandshakeRequest::set_r_version(const std::string& value) {
-  _internal_set_r_version(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeRequest::set_r_version(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.r_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.R_version)
 }
 inline std::string* HandshakeRequest::mutable_r_version() {
+  std::string* _s = _internal_mutable_r_version();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.R_version)
-  return _internal_mutable_r_version();
+  return _s;
 }
 inline const std::string& HandshakeRequest::_internal_r_version() const {
-  return r_version_.Get();
+  return _impl_.r_version_.Get();
 }
 inline void HandshakeRequest::_internal_set_r_version(const std::string& value) {
   
-  r_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void HandshakeRequest::set_r_version(std::string&& value) {
-  
-  r_version_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.HandshakeRequest.R_version)
-}
-inline void HandshakeRequest::set_r_version(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  r_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.HandshakeRequest.R_version)
-}
-inline void HandshakeRequest::set_r_version(const char* value,
-    size_t size) {
-  
-  r_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.HandshakeRequest.R_version)
+  _impl_.r_version_.Set(value, GetArenaForAllocation());
 }
 inline std::string* HandshakeRequest::_internal_mutable_r_version() {
   
-  return r_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.r_version_.Mutable(GetArenaForAllocation());
 }
 inline std::string* HandshakeRequest::release_r_version() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.HandshakeRequest.R_version)
-  return r_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.r_version_.Release();
 }
 inline void HandshakeRequest::set_allocated_r_version(std::string* r_version) {
   if (r_version != nullptr) {
@@ -1414,80 +1318,49 @@ inline void HandshakeRequest::set_allocated_r_version(std::string* r_version) {
   } else {
     
   }
-  r_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), r_version,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.R_version)
-}
-inline std::string* HandshakeRequest::unsafe_arena_release_r_version() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.HandshakeRequest.R_version)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return r_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void HandshakeRequest::unsafe_arena_set_allocated_r_version(
-    std::string* r_version) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (r_version != nullptr) {
-    
-  } else {
-    
+  _impl_.r_version_.SetAllocated(r_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.r_version_.IsDefault()) {
+    _impl_.r_version_.Set("", GetArenaForAllocation());
   }
-  r_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      r_version, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.HandshakeRequest.R_version)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.R_version)
 }
 
 // string platform = 3;
 inline void HandshakeRequest::clear_platform() {
-  platform_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.platform_.ClearToEmpty();
 }
 inline const std::string& HandshakeRequest::platform() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.platform)
   return _internal_platform();
 }
-inline void HandshakeRequest::set_platform(const std::string& value) {
-  _internal_set_platform(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HandshakeRequest::set_platform(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.platform)
 }
 inline std::string* HandshakeRequest::mutable_platform() {
+  std::string* _s = _internal_mutable_platform();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.platform)
-  return _internal_mutable_platform();
+  return _s;
 }
 inline const std::string& HandshakeRequest::_internal_platform() const {
-  return platform_.Get();
+  return _impl_.platform_.Get();
 }
 inline void HandshakeRequest::_internal_set_platform(const std::string& value) {
   
-  platform_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void HandshakeRequest::set_platform(std::string&& value) {
-  
-  platform_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.HandshakeRequest.platform)
-}
-inline void HandshakeRequest::set_platform(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  platform_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.HandshakeRequest.platform)
-}
-inline void HandshakeRequest::set_platform(const char* value,
-    size_t size) {
-  
-  platform_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.HandshakeRequest.platform)
+  _impl_.platform_.Set(value, GetArenaForAllocation());
 }
 inline std::string* HandshakeRequest::_internal_mutable_platform() {
   
-  return platform_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.platform_.Mutable(GetArenaForAllocation());
 }
 inline std::string* HandshakeRequest::release_platform() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.HandshakeRequest.platform)
-  return platform_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.platform_.Release();
 }
 inline void HandshakeRequest::set_allocated_platform(std::string* platform) {
   if (platform != nullptr) {
@@ -1495,46 +1368,32 @@ inline void HandshakeRequest::set_allocated_platform(std::string* platform) {
   } else {
     
   }
-  platform_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), platform,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.platform)
-}
-inline std::string* HandshakeRequest::unsafe_arena_release_platform() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.HandshakeRequest.platform)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return platform_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void HandshakeRequest::unsafe_arena_set_allocated_platform(
-    std::string* platform) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (platform != nullptr) {
-    
-  } else {
-    
+  _impl_.platform_.SetAllocated(platform, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.platform_.IsDefault()) {
+    _impl_.platform_.Set("", GetArenaForAllocation());
   }
-  platform_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      platform, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.HandshakeRequest.platform)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.platform)
 }
 
 // repeated string packages = 4;
 inline int HandshakeRequest::_internal_packages_size() const {
-  return packages_.size();
+  return _impl_.packages_.size();
 }
 inline int HandshakeRequest::packages_size() const {
   return _internal_packages_size();
 }
 inline void HandshakeRequest::clear_packages() {
-  packages_.Clear();
+  _impl_.packages_.Clear();
 }
 inline std::string* HandshakeRequest::add_packages() {
+  std::string* _s = _internal_add_packages();
   // @@protoc_insertion_point(field_add_mutable:rsh.server.protocol.HandshakeRequest.packages)
-  return _internal_add_packages();
+  return _s;
 }
 inline const std::string& HandshakeRequest::_internal_packages(int index) const {
-  return packages_.Get(index);
+  return _impl_.packages_.Get(index);
 }
 inline const std::string& HandshakeRequest::packages(int index) const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.packages)
@@ -1542,55 +1401,55 @@ inline const std::string& HandshakeRequest::packages(int index) const {
 }
 inline std::string* HandshakeRequest::mutable_packages(int index) {
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.packages)
-  return packages_.Mutable(index);
+  return _impl_.packages_.Mutable(index);
 }
 inline void HandshakeRequest::set_packages(int index, const std::string& value) {
+  _impl_.packages_.Mutable(index)->assign(value);
   // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.packages)
-  packages_.Mutable(index)->assign(value);
 }
 inline void HandshakeRequest::set_packages(int index, std::string&& value) {
+  _impl_.packages_.Mutable(index)->assign(std::move(value));
   // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.packages)
-  packages_.Mutable(index)->assign(std::move(value));
 }
 inline void HandshakeRequest::set_packages(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  packages_.Mutable(index)->assign(value);
+  _impl_.packages_.Mutable(index)->assign(value);
   // @@protoc_insertion_point(field_set_char:rsh.server.protocol.HandshakeRequest.packages)
 }
 inline void HandshakeRequest::set_packages(int index, const char* value, size_t size) {
-  packages_.Mutable(index)->assign(
+  _impl_.packages_.Mutable(index)->assign(
     reinterpret_cast<const char*>(value), size);
   // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.HandshakeRequest.packages)
 }
 inline std::string* HandshakeRequest::_internal_add_packages() {
-  return packages_.Add();
+  return _impl_.packages_.Add();
 }
 inline void HandshakeRequest::add_packages(const std::string& value) {
-  packages_.Add()->assign(value);
+  _impl_.packages_.Add()->assign(value);
   // @@protoc_insertion_point(field_add:rsh.server.protocol.HandshakeRequest.packages)
 }
 inline void HandshakeRequest::add_packages(std::string&& value) {
-  packages_.Add(std::move(value));
+  _impl_.packages_.Add(std::move(value));
   // @@protoc_insertion_point(field_add:rsh.server.protocol.HandshakeRequest.packages)
 }
 inline void HandshakeRequest::add_packages(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  packages_.Add()->assign(value);
+  _impl_.packages_.Add()->assign(value);
   // @@protoc_insertion_point(field_add_char:rsh.server.protocol.HandshakeRequest.packages)
 }
 inline void HandshakeRequest::add_packages(const char* value, size_t size) {
-  packages_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  _impl_.packages_.Add()->assign(reinterpret_cast<const char*>(value), size);
   // @@protoc_insertion_point(field_add_pointer:rsh.server.protocol.HandshakeRequest.packages)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
 HandshakeRequest::packages() const {
   // @@protoc_insertion_point(field_list:rsh.server.protocol.HandshakeRequest.packages)
-  return packages_;
+  return _impl_.packages_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
 HandshakeRequest::mutable_packages() {
   // @@protoc_insertion_point(field_mutable_list:rsh.server.protocol.HandshakeRequest.packages)
-  return &packages_;
+  return &_impl_.packages_;
 }
 
 // -------------------------------------------------------------------
@@ -1599,54 +1458,38 @@ HandshakeRequest::mutable_packages() {
 
 // string name = 2;
 inline void CompileRequest::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.name_.ClearToEmpty();
 }
 inline const std::string& CompileRequest::name() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.name)
   return _internal_name();
 }
-inline void CompileRequest::set_name(const std::string& value) {
-  _internal_set_name(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompileRequest::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.name)
 }
 inline std::string* CompileRequest::mutable_name() {
+  std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileRequest.name)
-  return _internal_mutable_name();
+  return _s;
 }
 inline const std::string& CompileRequest::_internal_name() const {
-  return name_.Get();
+  return _impl_.name_.Get();
 }
 inline void CompileRequest::_internal_set_name(const std::string& value) {
   
-  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void CompileRequest::set_name(std::string&& value) {
-  
-  name_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.CompileRequest.name)
-}
-inline void CompileRequest::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.CompileRequest.name)
-}
-inline void CompileRequest::set_name(const char* value,
-    size_t size) {
-  
-  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.CompileRequest.name)
+  _impl_.name_.Set(value, GetArenaForAllocation());
 }
 inline std::string* CompileRequest::_internal_mutable_name() {
   
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.name_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompileRequest::release_name() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileRequest.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.name_.Release();
 }
 inline void CompileRequest::set_allocated_name(std::string* name) {
   if (name != nullptr) {
@@ -1654,80 +1497,49 @@ inline void CompileRequest::set_allocated_name(std::string* name) {
   } else {
     
   }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileRequest.name)
-}
-inline std::string* CompileRequest::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompileRequest.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void CompileRequest::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
   }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompileRequest.name)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileRequest.name)
 }
 
 // bytes closure = 3;
 inline void CompileRequest::clear_closure() {
-  closure_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.closure_.ClearToEmpty();
 }
 inline const std::string& CompileRequest::closure() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.closure)
   return _internal_closure();
 }
-inline void CompileRequest::set_closure(const std::string& value) {
-  _internal_set_closure(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompileRequest::set_closure(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.closure_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.closure)
 }
 inline std::string* CompileRequest::mutable_closure() {
+  std::string* _s = _internal_mutable_closure();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileRequest.closure)
-  return _internal_mutable_closure();
+  return _s;
 }
 inline const std::string& CompileRequest::_internal_closure() const {
-  return closure_.Get();
+  return _impl_.closure_.Get();
 }
 inline void CompileRequest::_internal_set_closure(const std::string& value) {
   
-  closure_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void CompileRequest::set_closure(std::string&& value) {
-  
-  closure_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.CompileRequest.closure)
-}
-inline void CompileRequest::set_closure(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  closure_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.CompileRequest.closure)
-}
-inline void CompileRequest::set_closure(const void* value,
-    size_t size) {
-  
-  closure_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.CompileRequest.closure)
+  _impl_.closure_.Set(value, GetArenaForAllocation());
 }
 inline std::string* CompileRequest::_internal_mutable_closure() {
   
-  return closure_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.closure_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompileRequest::release_closure() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileRequest.closure)
-  return closure_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.closure_.Release();
 }
 inline void CompileRequest::set_allocated_closure(std::string* closure) {
   if (closure != nullptr) {
@@ -1735,66 +1547,51 @@ inline void CompileRequest::set_allocated_closure(std::string* closure) {
   } else {
     
   }
-  closure_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), closure,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileRequest.closure)
-}
-inline std::string* CompileRequest::unsafe_arena_release_closure() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompileRequest.closure)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return closure_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void CompileRequest::unsafe_arena_set_allocated_closure(
-    std::string* closure) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (closure != nullptr) {
-    
-  } else {
-    
+  _impl_.closure_.SetAllocated(closure, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.closure_.IsDefault()) {
+    _impl_.closure_.Set("", GetArenaForAllocation());
   }
-  closure_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      closure, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompileRequest.closure)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileRequest.closure)
 }
 
 // uint32 bc_optimization = 4;
 inline void CompileRequest::clear_bc_optimization() {
-  bc_optimization_ = 0u;
+  _impl_.bc_optimization_ = 0u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::uint32 CompileRequest::_internal_bc_optimization() const {
-  return bc_optimization_;
+inline uint32_t CompileRequest::_internal_bc_optimization() const {
+  return _impl_.bc_optimization_;
 }
-inline ::PROTOBUF_NAMESPACE_ID::uint32 CompileRequest::bc_optimization() const {
+inline uint32_t CompileRequest::bc_optimization() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.bc_optimization)
   return _internal_bc_optimization();
 }
-inline void CompileRequest::_internal_set_bc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+inline void CompileRequest::_internal_set_bc_optimization(uint32_t value) {
   
-  bc_optimization_ = value;
+  _impl_.bc_optimization_ = value;
 }
-inline void CompileRequest::set_bc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+inline void CompileRequest::set_bc_optimization(uint32_t value) {
   _internal_set_bc_optimization(value);
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.bc_optimization)
 }
 
 // uint32 cc_optimization = 5;
 inline void CompileRequest::clear_cc_optimization() {
-  cc_optimization_ = 0u;
+  _impl_.cc_optimization_ = 0u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::uint32 CompileRequest::_internal_cc_optimization() const {
-  return cc_optimization_;
+inline uint32_t CompileRequest::_internal_cc_optimization() const {
+  return _impl_.cc_optimization_;
 }
-inline ::PROTOBUF_NAMESPACE_ID::uint32 CompileRequest::cc_optimization() const {
+inline uint32_t CompileRequest::cc_optimization() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.cc_optimization)
   return _internal_cc_optimization();
 }
-inline void CompileRequest::_internal_set_cc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+inline void CompileRequest::_internal_set_cc_optimization(uint32_t value) {
   
-  cc_optimization_ = value;
+  _impl_.cc_optimization_ = value;
 }
-inline void CompileRequest::set_cc_optimization(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+inline void CompileRequest::set_cc_optimization(uint32_t value) {
   _internal_set_cc_optimization(value);
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.cc_optimization)
 }
@@ -1805,54 +1602,38 @@ inline void CompileRequest::set_cc_optimization(::PROTOBUF_NAMESPACE_ID::uint32
 
 // string name = 2;
 inline void CompiledFunction::clear_name() {
-  name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.name_.ClearToEmpty();
 }
 inline const std::string& CompiledFunction::name() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompiledFunction.name)
   return _internal_name();
 }
-inline void CompiledFunction::set_name(const std::string& value) {
-  _internal_set_name(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompiledFunction::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompiledFunction.name)
 }
 inline std::string* CompiledFunction::mutable_name() {
+  std::string* _s = _internal_mutable_name();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompiledFunction.name)
-  return _internal_mutable_name();
+  return _s;
 }
 inline const std::string& CompiledFunction::_internal_name() const {
-  return name_.Get();
+  return _impl_.name_.Get();
 }
 inline void CompiledFunction::_internal_set_name(const std::string& value) {
   
-  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void CompiledFunction::set_name(std::string&& value) {
-  
-  name_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.CompiledFunction.name)
-}
-inline void CompiledFunction::set_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.CompiledFunction.name)
-}
-inline void CompiledFunction::set_name(const char* value,
-    size_t size) {
-  
-  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.CompiledFunction.name)
+  _impl_.name_.Set(value, GetArenaForAllocation());
 }
 inline std::string* CompiledFunction::_internal_mutable_name() {
   
-  return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.name_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompiledFunction::release_name() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompiledFunction.name)
-  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.name_.Release();
 }
 inline void CompiledFunction::set_allocated_name(std::string* name) {
   if (name != nullptr) {
@@ -1860,80 +1641,49 @@ inline void CompiledFunction::set_allocated_name(std::string* name) {
   } else {
     
   }
-  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.name)
-}
-inline std::string* CompiledFunction::unsafe_arena_release_name() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompiledFunction.name)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void CompiledFunction::unsafe_arena_set_allocated_name(
-    std::string* name) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (name != nullptr) {
-    
-  } else {
-    
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
   }
-  name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      name, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompiledFunction.name)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.name)
 }
 
 // bytes native_code = 3;
 inline void CompiledFunction::clear_native_code() {
-  native_code_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.native_code_.ClearToEmpty();
 }
 inline const std::string& CompiledFunction::native_code() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompiledFunction.native_code)
   return _internal_native_code();
 }
-inline void CompiledFunction::set_native_code(const std::string& value) {
-  _internal_set_native_code(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompiledFunction::set_native_code(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.native_code_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompiledFunction.native_code)
 }
 inline std::string* CompiledFunction::mutable_native_code() {
+  std::string* _s = _internal_mutable_native_code();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompiledFunction.native_code)
-  return _internal_mutable_native_code();
+  return _s;
 }
 inline const std::string& CompiledFunction::_internal_native_code() const {
-  return native_code_.Get();
+  return _impl_.native_code_.Get();
 }
 inline void CompiledFunction::_internal_set_native_code(const std::string& value) {
   
-  native_code_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void CompiledFunction::set_native_code(std::string&& value) {
-  
-  native_code_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.CompiledFunction.native_code)
-}
-inline void CompiledFunction::set_native_code(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  native_code_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.CompiledFunction.native_code)
-}
-inline void CompiledFunction::set_native_code(const void* value,
-    size_t size) {
-  
-  native_code_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.CompiledFunction.native_code)
+  _impl_.native_code_.Set(value, GetArenaForAllocation());
 }
 inline std::string* CompiledFunction::_internal_mutable_native_code() {
   
-  return native_code_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.native_code_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompiledFunction::release_native_code() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompiledFunction.native_code)
-  return native_code_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.native_code_.Release();
 }
 inline void CompiledFunction::set_allocated_native_code(std::string* native_code) {
   if (native_code != nullptr) {
@@ -1941,80 +1691,49 @@ inline void CompiledFunction::set_allocated_native_code(std::string* native_code
   } else {
     
   }
-  native_code_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), native_code,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.native_code)
-}
-inline std::string* CompiledFunction::unsafe_arena_release_native_code() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompiledFunction.native_code)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return native_code_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void CompiledFunction::unsafe_arena_set_allocated_native_code(
-    std::string* native_code) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (native_code != nullptr) {
-    
-  } else {
-    
+  _impl_.native_code_.SetAllocated(native_code, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.native_code_.IsDefault()) {
+    _impl_.native_code_.Set("", GetArenaForAllocation());
   }
-  native_code_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      native_code, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompiledFunction.native_code)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.native_code)
 }
 
 // bytes constants = 4;
 inline void CompiledFunction::clear_constants() {
-  constants_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _impl_.constants_.ClearToEmpty();
 }
 inline const std::string& CompiledFunction::constants() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompiledFunction.constants)
   return _internal_constants();
 }
-inline void CompiledFunction::set_constants(const std::string& value) {
-  _internal_set_constants(value);
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompiledFunction::set_constants(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.constants_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompiledFunction.constants)
 }
 inline std::string* CompiledFunction::mutable_constants() {
+  std::string* _s = _internal_mutable_constants();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompiledFunction.constants)
-  return _internal_mutable_constants();
+  return _s;
 }
 inline const std::string& CompiledFunction::_internal_constants() const {
-  return constants_.Get();
+  return _impl_.constants_.Get();
 }
 inline void CompiledFunction::_internal_set_constants(const std::string& value) {
   
-  constants_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void CompiledFunction::set_constants(std::string&& value) {
-  
-  constants_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.CompiledFunction.constants)
-}
-inline void CompiledFunction::set_constants(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  
-  constants_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
-              GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.CompiledFunction.constants)
-}
-inline void CompiledFunction::set_constants(const void* value,
-    size_t size) {
-  
-  constants_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size), GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.CompiledFunction.constants)
+  _impl_.constants_.Set(value, GetArenaForAllocation());
 }
 inline std::string* CompiledFunction::_internal_mutable_constants() {
   
-  return constants_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.constants_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompiledFunction::release_constants() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompiledFunction.constants)
-  return constants_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.constants_.Release();
 }
 inline void CompiledFunction::set_allocated_constants(std::string* constants) {
   if (constants != nullptr) {
@@ -2022,28 +1741,13 @@ inline void CompiledFunction::set_allocated_constants(std::string* constants) {
   } else {
     
   }
-  constants_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), constants,
-      GetArena());
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.constants)
-}
-inline std::string* CompiledFunction::unsafe_arena_release_constants() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompiledFunction.constants)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  
-  return constants_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      GetArena());
-}
-inline void CompiledFunction::unsafe_arena_set_allocated_constants(
-    std::string* constants) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (constants != nullptr) {
-    
-  } else {
-    
+  _impl_.constants_.SetAllocated(constants, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.constants_.IsDefault()) {
+    _impl_.constants_.Set("", GetArenaForAllocation());
   }
-  constants_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      constants, GetArena());
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompiledFunction.constants)
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.constants)
 }
 
 // -------------------------------------------------------------------
@@ -2054,12 +1758,15 @@ inline void CompiledFunction::unsafe_arena_set_allocated_constants(
 inline bool CompileResponse::_internal_has_failure() const {
   return data_case() == kFailure;
 }
+inline bool CompileResponse::has_failure() const {
+  return _internal_has_failure();
+}
 inline void CompileResponse::set_has_failure() {
-  _oneof_case_[0] = kFailure;
+  _impl_._oneof_case_[0] = kFailure;
 }
 inline void CompileResponse::clear_failure() {
   if (_internal_has_failure()) {
-    data_.failure_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+    _impl_.data_.failure_.Destroy();
     clear_has_data();
   }
 }
@@ -2067,76 +1774,48 @@ inline const std::string& CompileResponse::failure() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileResponse.failure)
   return _internal_failure();
 }
-inline void CompileResponse::set_failure(const std::string& value) {
-  _internal_set_failure(value);
+template <typename ArgT0, typename... ArgT>
+inline void CompileResponse::set_failure(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_failure()) {
+    clear_data();
+    set_has_failure();
+    _impl_.data_.failure_.InitDefault();
+  }
+  _impl_.data_.failure_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
   // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileResponse.failure)
 }
 inline std::string* CompileResponse::mutable_failure() {
+  std::string* _s = _internal_mutable_failure();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileResponse.failure)
-  return _internal_mutable_failure();
+  return _s;
 }
 inline const std::string& CompileResponse::_internal_failure() const {
   if (_internal_has_failure()) {
-    return data_.failure_.Get();
+    return _impl_.data_.failure_.Get();
   }
-  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 }
 inline void CompileResponse::_internal_set_failure(const std::string& value) {
   if (!_internal_has_failure()) {
     clear_data();
     set_has_failure();
-    data_.failure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  data_.failure_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
-}
-inline void CompileResponse::set_failure(std::string&& value) {
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileResponse.failure)
-  if (!_internal_has_failure()) {
-    clear_data();
-    set_has_failure();
-    data_.failure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  data_.failure_.Set(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
-  // @@protoc_insertion_point(field_set_rvalue:rsh.server.protocol.CompileResponse.failure)
-}
-inline void CompileResponse::set_failure(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  if (!_internal_has_failure()) {
-    clear_data();
-    set_has_failure();
-    data_.failure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  data_.failure_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value), GetArena());
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.CompileResponse.failure)
-}
-inline void CompileResponse::set_failure(const char* value,
-                             size_t size) {
-  if (!_internal_has_failure()) {
-    clear_data();
-    set_has_failure();
-    data_.failure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    _impl_.data_.failure_.InitDefault();
   }
-  data_.failure_.Set(
-      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size),
-      GetArena());
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.CompileResponse.failure)
+  _impl_.data_.failure_.Set(value, GetArenaForAllocation());
 }
 inline std::string* CompileResponse::_internal_mutable_failure() {
   if (!_internal_has_failure()) {
     clear_data();
     set_has_failure();
-    data_.failure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    _impl_.data_.failure_.InitDefault();
   }
-  return data_.failure_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  return _impl_.data_.failure_.Mutable(      GetArenaForAllocation());
 }
 inline std::string* CompileResponse::release_failure() {
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileResponse.failure)
   if (_internal_has_failure()) {
     clear_has_data();
-    return data_.failure_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+    return _impl_.data_.failure_.Release();
   } else {
     return nullptr;
   }
@@ -2147,33 +1826,10 @@ inline void CompileResponse::set_allocated_failure(std::string* failure) {
   }
   if (failure != nullptr) {
     set_has_failure();
-    data_.failure_.UnsafeSetDefault(failure);
+    _impl_.data_.failure_.InitAllocated(failure, GetArenaForAllocation());
   }
   // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileResponse.failure)
 }
-inline std::string* CompileResponse::unsafe_arena_release_failure() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompileResponse.failure)
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (_internal_has_failure()) {
-    clear_has_data();
-    return data_.failure_.UnsafeArenaRelease(
-        &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-  } else {
-    return nullptr;
-  }
-}
-inline void CompileResponse::unsafe_arena_set_allocated_failure(std::string* failure) {
-  GOOGLE_DCHECK(GetArena() != nullptr);
-  if (!_internal_has_failure()) {
-    data_.failure_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_data();
-  if (failure) {
-    set_has_failure();
-    data_.failure_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), failure, GetArena());
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompileResponse.failure)
-}
 
 // .rsh.server.protocol.CompiledFunction result = 3;
 inline bool CompileResponse::_internal_has_result() const {
@@ -2183,12 +1839,12 @@ inline bool CompileResponse::has_result() const {
   return _internal_has_result();
 }
 inline void CompileResponse::set_has_result() {
-  _oneof_case_[0] = kResult;
+  _impl_._oneof_case_[0] = kResult;
 }
 inline void CompileResponse::clear_result() {
   if (_internal_has_result()) {
-    if (GetArena() == nullptr) {
-      delete data_.result_;
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.data_.result_;
     }
     clear_has_data();
   }
@@ -2197,11 +1853,11 @@ inline ::rsh::server::protocol::CompiledFunction* CompileResponse::release_resul
   // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileResponse.result)
   if (_internal_has_result()) {
     clear_has_data();
-      ::rsh::server::protocol::CompiledFunction* temp = data_.result_;
-    if (GetArena() != nullptr) {
+    ::rsh::server::protocol::CompiledFunction* temp = _impl_.data_.result_;
+    if (GetArenaForAllocation() != nullptr) {
       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
     }
-    data_.result_ = nullptr;
+    _impl_.data_.result_ = nullptr;
     return temp;
   } else {
     return nullptr;
@@ -2209,8 +1865,8 @@ inline ::rsh::server::protocol::CompiledFunction* CompileResponse::release_resul
 }
 inline const ::rsh::server::protocol::CompiledFunction& CompileResponse::_internal_result() const {
   return _internal_has_result()
-      ? *data_.result_
-      : *reinterpret_cast< ::rsh::server::protocol::CompiledFunction*>(&::rsh::server::protocol::_CompiledFunction_default_instance_);
+      ? *_impl_.data_.result_
+      : reinterpret_cast< ::rsh::server::protocol::CompiledFunction&>(::rsh::server::protocol::_CompiledFunction_default_instance_);
 }
 inline const ::rsh::server::protocol::CompiledFunction& CompileResponse::result() const {
   // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileResponse.result)
@@ -2220,8 +1876,8 @@ inline ::rsh::server::protocol::CompiledFunction* CompileResponse::unsafe_arena_
   // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompileResponse.result)
   if (_internal_has_result()) {
     clear_has_data();
-    ::rsh::server::protocol::CompiledFunction* temp = data_.result_;
-    data_.result_ = nullptr;
+    ::rsh::server::protocol::CompiledFunction* temp = _impl_.data_.result_;
+    _impl_.data_.result_ = nullptr;
     return temp;
   } else {
     return nullptr;
@@ -2231,7 +1887,7 @@ inline void CompileResponse::unsafe_arena_set_allocated_result(::rsh::server::pr
   clear_data();
   if (result) {
     set_has_result();
-    data_.result_ = result;
+    _impl_.data_.result_ = result;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompileResponse.result)
 }
@@ -2239,23 +1895,24 @@ inline ::rsh::server::protocol::CompiledFunction* CompileResponse::_internal_mut
   if (!_internal_has_result()) {
     clear_data();
     set_has_result();
-    data_.result_ = CreateMaybeMessage< ::rsh::server::protocol::CompiledFunction >(GetArena());
+    _impl_.data_.result_ = CreateMaybeMessage< ::rsh::server::protocol::CompiledFunction >(GetArenaForAllocation());
   }
-  return data_.result_;
+  return _impl_.data_.result_;
 }
 inline ::rsh::server::protocol::CompiledFunction* CompileResponse::mutable_result() {
+  ::rsh::server::protocol::CompiledFunction* _msg = _internal_mutable_result();
   // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileResponse.result)
-  return _internal_mutable_result();
+  return _msg;
 }
 
 inline bool CompileResponse::has_data() const {
   return data_case() != DATA_NOT_SET;
 }
 inline void CompileResponse::clear_has_data() {
-  _oneof_case_[0] = DATA_NOT_SET;
+  _impl_._oneof_case_[0] = DATA_NOT_SET;
 }
 inline CompileResponse::DataCase CompileResponse::data_case() const {
-  return CompileResponse::DataCase(_oneof_case_[0]);
+  return CompileResponse::DataCase(_impl_._oneof_case_[0]);
 }
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
diff --git a/external/R b/external/R
index 02cb3ab35..bef9591e3 160000
--- a/external/R
+++ b/external/R
@@ -1 +1 @@
-Subproject commit 02cb3ab35337e154a3d200a2dc6f54a307bc3ba5
+Subproject commit bef9591e3136f918d9aabfaf706f6b5283794d6f

From 4cc2d5045861afdcf448385aba6f3c8fba21fbcc Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 8 Aug 2024 17:42:14 +0200
Subject: [PATCH 35/80] Makefile to generate C++ files from the proto

---
 proto/Makefile | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 proto/Makefile

diff --git a/proto/Makefile b/proto/Makefile
new file mode 100644
index 000000000..cef7b89dd
--- /dev/null
+++ b/proto/Makefile
@@ -0,0 +1,4 @@
+CPP_DEST := ../client//rsh/src
+
+all:
+	protoc --cpp_out=$(CPP_DEST)  messages.proto routes.proto
\ No newline at end of file

From f2d3ed937827e0d158c98764f9ad57b634c118ea Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 9 Aug 2024 16:27:42 +0200
Subject: [PATCH 36/80] Start of gRPC in the client

---
 .vscode/settings.json         |   75 +-
 client/rsh/src/client.cpp     |   43 +-
 client/rsh/src/messages.pb.cc | 6917 +++++++++++++++++++++++++++++
 client/rsh/src/messages.pb.h  | 7721 +++++++++++++++++++++++++++++++++
 client/rsh/src/routes.pb.cc   |   65 +
 client/rsh/src/routes.pb.h    |   71 +
 6 files changed, 14890 insertions(+), 2 deletions(-)
 create mode 100644 client/rsh/src/messages.pb.cc
 create mode 100644 client/rsh/src/messages.pb.h
 create mode 100644 client/rsh/src/routes.pb.cc
 create mode 100644 client/rsh/src/routes.pb.h

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 8f2b7113d..01f8d03c5 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,76 @@
 {
-    "java.compile.nullAnalysis.mode": "disabled"
+    "java.compile.nullAnalysis.mode": "disabled",
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "cinttypes": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "format": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "semaphore": "cpp",
+        "shared_mutex": "cpp",
+        "span": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cfenv": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp",
+        "text_encoding": "cpp"
+    }
 }
\ No newline at end of file
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 1e2b82d56..3338817ed 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -1,5 +1,6 @@
 #include "client.h"
-#include "protocol.pb.h"
+#include "messages.pb.h"
+#include "routes.pb.h"
 #include <iostream>
 
 namespace rsh {
@@ -39,4 +40,44 @@ CompileResponse remote_compile(std::string const &name,
 
   return response;
 }
+
+class Client {
+private:
+  std::unique_ptr<RouteGuide::Stub> stub_;
+
+public:
+  Client(std::shared_ptr<Channel> channel) : stub_(Routes::NewStub(channel)) {
+
+    // TODO: send handshake here?
+  }
+
+  CompileResponse remote_compile(std::string const& name, 
+                                std::vector<uint8_t> const &rds_closure,
+                                Tier tier,
+                                int32_t optimization_level) {
+
+    CompileRequest request;
+    request.set_tier(tier);
+    request.set_optimization_level(optimization_level);
+    request.mutable_function().set_name(name);
+    request.mutable_function().set_body(rds_closure.data(), rds_closure.size());
+
+    // TODO: Actually compile the hash
+    std::array<uint8_t,64> hash = {0};
+    request.mutable_function().set_hash(hash.data(), hash.size());
+
+    ClientContext context;
+    CompileResponse response;
+    Status status = _stub->Compile(&context, request, &response);
+    if(!status.ok()) {
+      std::err << status.error_code() << ": " << status.error_message()
+                << std::endl;
+      exit(1);//TODO: rather return an optional?
+    }
+    else {
+      return response;
+    }
+  }
+};
+
 } // namespace rsh
diff --git a/client/rsh/src/messages.pb.cc b/client/rsh/src/messages.pb.cc
new file mode 100644
index 000000000..7b7ff64c6
--- /dev/null
+++ b/client/rsh/src/messages.pb.cc
@@ -0,0 +1,6917 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: messages.proto
+
+#include "messages.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+PROTOBUF_CONSTEXPR Version::Version(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.major_)*/0
+  , /*decltype(_impl_.minor_)*/0
+  , /*decltype(_impl_.patch_)*/0
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct VersionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR VersionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~VersionDefaultTypeInternal() {}
+  union {
+    Version _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VersionDefaultTypeInternal _Version_default_instance_;
+PROTOBUF_CONSTEXPR InitRequest::InitRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.package_hash_)*/{}
+  , /*decltype(_impl_.platform_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.rsh_version_)*/nullptr
+  , /*decltype(_impl_.r_version_)*/nullptr
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct InitRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR InitRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~InitRequestDefaultTypeInternal() {}
+  union {
+    InitRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InitRequestDefaultTypeInternal _InitRequest_default_instance_;
+PROTOBUF_CONSTEXPR InitResponse::InitResponse(
+    ::_pbi::ConstantInitialized) {}
+struct InitResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR InitResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~InitResponseDefaultTypeInternal() {}
+  union {
+    InitResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InitResponseDefaultTypeInternal _InitResponse_default_instance_;
+PROTOBUF_CONSTEXPR CompileRequest::CompileRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.function_)*/nullptr
+  , /*decltype(_impl_.context_)*/nullptr
+  , /*decltype(_impl_.environment_)*/nullptr
+  , /*decltype(_impl_.tier_)*/0
+  , /*decltype(_impl_.optimization_level_)*/0} {}
+struct CompileRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CompileRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CompileRequestDefaultTypeInternal() {}
+  union {
+    CompileRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompileRequestDefaultTypeInternal _CompileRequest_default_instance_;
+PROTOBUF_CONSTEXPR CompileResponse::CompileResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.constant_pool_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.tier_)*/0} {}
+struct CompileResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CompileResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CompileResponseDefaultTypeInternal() {}
+  union {
+    CompileResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompileResponseDefaultTypeInternal _CompileResponse_default_instance_;
+PROTOBUF_CONSTEXPR Function::Function(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.package_hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct FunctionDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR FunctionDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~FunctionDefaultTypeInternal() {}
+  union {
+    Function _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FunctionDefaultTypeInternal _Function_default_instance_;
+PROTOBUF_CONSTEXPR FunctionRequest::FunctionRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct FunctionRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR FunctionRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~FunctionRequestDefaultTypeInternal() {}
+  union {
+    FunctionRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FunctionRequestDefaultTypeInternal _FunctionRequest_default_instance_;
+PROTOBUF_CONSTEXPR Environment_ValuesEntry_DoNotUse::Environment_ValuesEntry_DoNotUse(
+    ::_pbi::ConstantInitialized) {}
+struct Environment_ValuesEntry_DoNotUseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR Environment_ValuesEntry_DoNotUseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~Environment_ValuesEntry_DoNotUseDefaultTypeInternal() {}
+  union {
+    Environment_ValuesEntry_DoNotUse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Environment_ValuesEntry_DoNotUseDefaultTypeInternal _Environment_ValuesEntry_DoNotUse_default_instance_;
+PROTOBUF_CONSTEXPR Environment::Environment(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.values_)*/{::_pbi::ConstantInitialized()}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct EnvironmentDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR EnvironmentDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~EnvironmentDefaultTypeInternal() {}
+  union {
+    Environment _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EnvironmentDefaultTypeInternal _Environment_default_instance_;
+PROTOBUF_CONSTEXPR ValueRequest::ValueRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.hash_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ValueRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ValueRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ValueRequestDefaultTypeInternal() {}
+  union {
+    ValueRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueRequestDefaultTypeInternal _ValueRequest_default_instance_;
+PROTOBUF_CONSTEXPR Value::Value(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ValueDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ValueDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ValueDefaultTypeInternal() {}
+  union {
+    Value _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueDefaultTypeInternal _Value_default_instance_;
+PROTOBUF_CONSTEXPR Values::Values(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.values_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ValuesDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ValuesDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ValuesDefaultTypeInternal() {}
+  union {
+    Values _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValuesDefaultTypeInternal _Values_default_instance_;
+PROTOBUF_CONSTEXPR Empty::Empty(
+    ::_pbi::ConstantInitialized) {}
+struct EmptyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR EmptyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~EmptyDefaultTypeInternal() {}
+  union {
+    Empty _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmptyDefaultTypeInternal _Empty_default_instance_;
+PROTOBUF_CONSTEXPR CallContext::CallContext(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.args_statically_matched_)*/false
+  , /*decltype(_impl_.correct_number_of_args_)*/false
+  , /*decltype(_impl_.correct_order_of_args_)*/false
+  , /*decltype(_impl_.no_missing_args_)*/false
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct CallContextDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CallContextDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CallContextDefaultTypeInternal() {}
+  union {
+    CallContext _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CallContextDefaultTypeInternal _CallContext_default_instance_;
+PROTOBUF_CONSTEXPR ArgumentContext::ArgumentContext(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.eager_)*/false
+  , /*decltype(_impl_.reflection_)*/false
+  , /*decltype(_impl_.object_)*/false
+  , /*decltype(_impl_.type_)*/0} {}
+struct ArgumentContextDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ArgumentContextDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ArgumentContextDefaultTypeInternal() {}
+  union {
+    ArgumentContext _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ArgumentContextDefaultTypeInternal _ArgumentContext_default_instance_;
+PROTOBUF_CONSTEXPR Context::Context(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.argument_context_)*/{}
+  , /*decltype(_impl_.call_context_)*/nullptr
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ContextDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ContextDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ContextDefaultTypeInternal() {}
+  union {
+    Context _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextDefaultTypeInternal _Context_default_instance_;
+PROTOBUF_CONSTEXPR ContextRequest::ContextRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.function_)*/nullptr
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ContextRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ContextRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ContextRequestDefaultTypeInternal() {}
+  union {
+    ContextRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextRequestDefaultTypeInternal _ContextRequest_default_instance_;
+PROTOBUF_CONSTEXPR TestFeedback::TestFeedback(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.test_lattice_)*/0
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct TestFeedbackDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TestFeedbackDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TestFeedbackDefaultTypeInternal() {}
+  union {
+    TestFeedback _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TestFeedbackDefaultTypeInternal _TestFeedback_default_instance_;
+PROTOBUF_CONSTEXPR CallFeedback::CallFeedback(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.callee_hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.n_calls_)*/int64_t{0}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct CallFeedbackDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CallFeedbackDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CallFeedbackDefaultTypeInternal() {}
+  union {
+    CallFeedback _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CallFeedbackDefaultTypeInternal _CallFeedback_default_instance_;
+PROTOBUF_CONSTEXPR ValueFeedback::ValueFeedback(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.scalar_)*/false
+  , /*decltype(_impl_.object_)*/false
+  , /*decltype(_impl_.accessed_attributes_)*/false
+  , /*decltype(_impl_.vectorizable_)*/false
+  , /*decltype(_impl_.is_promise_)*/false
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ValueFeedbackDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ValueFeedbackDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ValueFeedbackDefaultTypeInternal() {}
+  union {
+    ValueFeedback _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueFeedbackDefaultTypeInternal _ValueFeedback_default_instance_;
+PROTOBUF_CONSTEXPR TypeFeedback_Feedback::TypeFeedback_Feedback(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.feedback_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct TypeFeedback_FeedbackDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TypeFeedback_FeedbackDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TypeFeedback_FeedbackDefaultTypeInternal() {}
+  union {
+    TypeFeedback_Feedback _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeFeedback_FeedbackDefaultTypeInternal _TypeFeedback_Feedback_default_instance_;
+PROTOBUF_CONSTEXPR TypeFeedback_TypesEntry_DoNotUse::TypeFeedback_TypesEntry_DoNotUse(
+    ::_pbi::ConstantInitialized) {}
+struct TypeFeedback_TypesEntry_DoNotUseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TypeFeedback_TypesEntry_DoNotUseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TypeFeedback_TypesEntry_DoNotUseDefaultTypeInternal() {}
+  union {
+    TypeFeedback_TypesEntry_DoNotUse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeFeedback_TypesEntry_DoNotUseDefaultTypeInternal _TypeFeedback_TypesEntry_DoNotUse_default_instance_;
+PROTOBUF_CONSTEXPR TypeFeedback::TypeFeedback(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.types_)*/{::_pbi::ConstantInitialized()}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct TypeFeedbackDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TypeFeedbackDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TypeFeedbackDefaultTypeInternal() {}
+  union {
+    TypeFeedback _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeFeedbackDefaultTypeInternal _TypeFeedback_default_instance_;
+PROTOBUF_CONSTEXPR FeedbackRequest::FeedbackRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.function_)*/nullptr
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct FeedbackRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR FeedbackRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~FeedbackRequestDefaultTypeInternal() {}
+  union {
+    FeedbackRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeedbackRequestDefaultTypeInternal _FeedbackRequest_default_instance_;
+PROTOBUF_CONSTEXPR PackageSource::PackageSource(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.source_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_._oneof_case_)*/{}} {}
+struct PackageSourceDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PackageSourceDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PackageSourceDefaultTypeInternal() {}
+  union {
+    PackageSource _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PackageSourceDefaultTypeInternal _PackageSource_default_instance_;
+PROTOBUF_CONSTEXPR Package::Package(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.function_hashes_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/nullptr
+  , /*decltype(_impl_.source_)*/nullptr} {}
+struct PackageDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PackageDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PackageDefaultTypeInternal() {}
+  union {
+    Package _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PackageDefaultTypeInternal _Package_default_instance_;
+PROTOBUF_CONSTEXPR PackageRequest::PackageRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct PackageRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PackageRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PackageRequestDefaultTypeInternal() {}
+  union {
+    PackageRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PackageRequestDefaultTypeInternal _PackageRequest_default_instance_;
+static ::_pb::Metadata file_level_metadata_messages_2eproto[27];
+static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2eproto[3];
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_messages_2eproto = nullptr;
+
+const uint32_t TableStruct_messages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::Version, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Version, _impl_.major_),
+  PROTOBUF_FIELD_OFFSET(::Version, _impl_.minor_),
+  PROTOBUF_FIELD_OFFSET(::Version, _impl_.patch_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::InitRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.rsh_version_),
+  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.r_version_),
+  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.platform_),
+  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.package_hash_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::InitResponse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.function_),
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.tier_),
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.optimization_level_),
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.context_),
+  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.environment_),
+  ~0u,
+  2,
+  3,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::CompileResponse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.tier_),
+  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.code_),
+  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.constant_pool_),
+  ~0u,
+  ~0u,
+  0,
+  1,
+  PROTOBUF_FIELD_OFFSET(::Function, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::Function, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Function, _impl_.package_hash_),
+  PROTOBUF_FIELD_OFFSET(::Function, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::Function, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::Function, _impl_.body_),
+  ~0u,
+  ~0u,
+  ~0u,
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::FunctionRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::FunctionRequest, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, key_),
+  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, value_),
+  0,
+  1,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::Environment, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Environment, _impl_.values_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::ValueRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::ValueRequest, _impl_.hash_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::Value, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Value, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::Value, _impl_.value_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::Values, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Values, _impl_.values_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::Empty, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::CallContext, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.args_statically_matched_),
+  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.correct_number_of_args_),
+  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.correct_order_of_args_),
+  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.no_missing_args_),
+  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.eager_),
+  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.reflection_),
+  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.object_),
+  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.type_),
+  ~0u,
+  ~0u,
+  ~0u,
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::Context, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Context, _impl_.call_context_),
+  PROTOBUF_FIELD_OFFSET(::Context, _impl_.argument_context_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::ContextRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::ContextRequest, _impl_.function_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::TestFeedback, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::TestFeedback, _impl_.test_lattice_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::CallFeedback, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::CallFeedback, _impl_.n_calls_),
+  PROTOBUF_FIELD_OFFSET(::CallFeedback, _impl_.callee_hash_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.scalar_),
+  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.object_),
+  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.accessed_attributes_),
+  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.vectorizable_),
+  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.is_promise_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_Feedback, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_Feedback, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_Feedback, _impl_.feedback_),
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, key_),
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, value_),
+  0,
+  1,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::TypeFeedback, _impl_.types_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::FeedbackRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::FeedbackRequest, _impl_.function_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::PackageSource, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::PackageSource, _impl_._oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::_pbi::kInvalidFieldOffsetTag,
+  ::_pbi::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::PackageSource, _impl_.source_),
+  PROTOBUF_FIELD_OFFSET(::Package, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::Package, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::Package, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::Package, _impl_.version_),
+  PROTOBUF_FIELD_OFFSET(::Package, _impl_.function_hashes_),
+  PROTOBUF_FIELD_OFFSET(::Package, _impl_.source_),
+  ~0u,
+  ~0u,
+  ~0u,
+  0,
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::PackageRequest, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::PackageRequest, _impl_.hash_),
+};
+static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::Version)},
+  { 9, -1, -1, sizeof(::InitRequest)},
+  { 19, -1, -1, sizeof(::InitResponse)},
+  { 25, 36, -1, sizeof(::CompileRequest)},
+  { 41, 51, -1, sizeof(::CompileResponse)},
+  { 55, 65, -1, sizeof(::Function)},
+  { 69, -1, -1, sizeof(::FunctionRequest)},
+  { 76, 84, -1, sizeof(::Environment_ValuesEntry_DoNotUse)},
+  { 86, -1, -1, sizeof(::Environment)},
+  { 93, -1, -1, sizeof(::ValueRequest)},
+  { 100, -1, -1, sizeof(::Value)},
+  { 108, -1, -1, sizeof(::Values)},
+  { 115, -1, -1, sizeof(::Empty)},
+  { 121, -1, -1, sizeof(::CallContext)},
+  { 131, 141, -1, sizeof(::ArgumentContext)},
+  { 145, -1, -1, sizeof(::Context)},
+  { 153, -1, -1, sizeof(::ContextRequest)},
+  { 160, -1, -1, sizeof(::TestFeedback)},
+  { 167, -1, -1, sizeof(::CallFeedback)},
+  { 175, -1, -1, sizeof(::ValueFeedback)},
+  { 186, -1, -1, sizeof(::TypeFeedback_Feedback)},
+  { 196, 204, -1, sizeof(::TypeFeedback_TypesEntry_DoNotUse)},
+  { 206, -1, -1, sizeof(::TypeFeedback)},
+  { 213, -1, -1, sizeof(::FeedbackRequest)},
+  { 220, -1, -1, sizeof(::PackageSource)},
+  { 229, 239, -1, sizeof(::Package)},
+  { 243, -1, -1, sizeof(::PackageRequest)},
+};
+
+static const ::_pb::Message* const file_default_instances[] = {
+  &::_Version_default_instance_._instance,
+  &::_InitRequest_default_instance_._instance,
+  &::_InitResponse_default_instance_._instance,
+  &::_CompileRequest_default_instance_._instance,
+  &::_CompileResponse_default_instance_._instance,
+  &::_Function_default_instance_._instance,
+  &::_FunctionRequest_default_instance_._instance,
+  &::_Environment_ValuesEntry_DoNotUse_default_instance_._instance,
+  &::_Environment_default_instance_._instance,
+  &::_ValueRequest_default_instance_._instance,
+  &::_Value_default_instance_._instance,
+  &::_Values_default_instance_._instance,
+  &::_Empty_default_instance_._instance,
+  &::_CallContext_default_instance_._instance,
+  &::_ArgumentContext_default_instance_._instance,
+  &::_Context_default_instance_._instance,
+  &::_ContextRequest_default_instance_._instance,
+  &::_TestFeedback_default_instance_._instance,
+  &::_CallFeedback_default_instance_._instance,
+  &::_ValueFeedback_default_instance_._instance,
+  &::_TypeFeedback_Feedback_default_instance_._instance,
+  &::_TypeFeedback_TypesEntry_DoNotUse_default_instance_._instance,
+  &::_TypeFeedback_default_instance_._instance,
+  &::_FeedbackRequest_default_instance_._instance,
+  &::_PackageSource_default_instance_._instance,
+  &::_Package_default_instance_._instance,
+  &::_PackageRequest_default_instance_._instance,
+};
+
+const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\016messages.proto\"6\n\007Version\022\r\n\005major\030\001 \001"
+  "(\005\022\r\n\005minor\030\002 \001(\005\022\r\n\005patch\030\003 \001(\005\"q\n\013Init"
+  "Request\022\035\n\013Rsh_version\030\001 \001(\0132\010.Version\022\033"
+  "\n\tR_version\030\002 \001(\0132\010.Version\022\020\n\010platform\030"
+  "\003 \001(\t\022\024\n\014package_hash\030\004 \003(\014\"\016\n\014InitRespo"
+  "nse\"\354\001\n\016CompileRequest\022\033\n\010function\030\002 \001(\013"
+  "2\t.Function\022\030\n\004tier\030\004 \001(\0162\005.TierH\000\210\001\001\022\037\n"
+  "\022optimization_level\030\005 \001(\005H\001\210\001\001\022\036\n\007contex"
+  "t\030\006 \001(\0132\010.ContextH\002\210\001\001\022&\n\013environment\030\007 "
+  "\001(\0132\014.EnvironmentH\003\210\001\001B\007\n\005_tierB\025\n\023_opti"
+  "mization_levelB\n\n\010_contextB\016\n\014_environme"
+  "nt\"~\n\017CompileResponse\022\014\n\004hash\030\001 \001(\014\022\023\n\004t"
+  "ier\030\002 \001(\0162\005.Tier\022\021\n\004code\030\003 \001(\014H\000\210\001\001\022\032\n\rc"
+  "onstant_pool\030\004 \001(\014H\001\210\001\001B\007\n\005_codeB\020\n\016_con"
+  "stant_pool\"X\n\010Function\022\024\n\014package_hash\030\001"
+  " \001(\014\022\014\n\004name\030\002 \001(\t\022\014\n\004hash\030\003 \001(\014\022\021\n\004body"
+  "\030\004 \001(\014H\000\210\001\001B\007\n\005_body\"\037\n\017FunctionRequest\022"
+  "\014\n\004hash\030\001 \001(\014\"f\n\013Environment\022(\n\006values\030\001"
+  " \003(\0132\030.Environment.ValuesEntry\032-\n\013Values"
+  "Entry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014:\0028\001\"\034\n"
+  "\014ValueRequest\022\014\n\004hash\030\001 \003(\014\"$\n\005Value\022\014\n\004"
+  "hash\030\001 \001(\014\022\r\n\005value\030\002 \001(\014\" \n\006Values\022\026\n\006v"
+  "alues\030\001 \003(\0132\006.Value\"\007\n\005Empty\"\206\001\n\013CallCon"
+  "text\022\037\n\027args_statically_matched\030\001 \001(\010\022\036\n"
+  "\026correct_number_of_args\030\002 \001(\010\022\035\n\025correct"
+  "_order_of_args\030\003 \001(\010\022\027\n\017no_missing_args\030"
+  "\004 \001(\010\"g\n\017ArgumentContext\022\r\n\005eager\030\001 \001(\010\022"
+  "\022\n\nreflection\030\002 \001(\010\022\016\n\006object\030\003 \001(\010\022\030\n\004t"
+  "ype\030\004 \001(\0162\005.TypeH\000\210\001\001B\007\n\005_type\"Y\n\007Contex"
+  "t\022\"\n\014call_context\030\001 \001(\0132\014.CallContext\022*\n"
+  "\020argument_context\030\002 \003(\0132\020.ArgumentContex"
+  "t\"-\n\016ContextRequest\022\033\n\010function\030\001 \001(\0132\t."
+  "Function\"2\n\014TestFeedback\022\"\n\014test_lattice"
+  "\030\001 \001(\0162\014.TestLattice\"4\n\014CallFeedback\022\017\n\007"
+  "n_calls\030\001 \001(\003\022\023\n\013callee_hash\030\002 \001(\014\"v\n\rVa"
+  "lueFeedback\022\016\n\006scalar\030\001 \001(\010\022\016\n\006object\030\002 "
+  "\001(\010\022\033\n\023accessed_attributes\030\003 \001(\010\022\024\n\014vect"
+  "orizable\030\004 \001(\010\022\022\n\nis_promise\030\005 \001(\010\"\220\002\n\014T"
+  "ypeFeedback\022\'\n\005types\030\002 \003(\0132\030.TypeFeedbac"
+  "k.TypesEntry\032\220\001\n\010Feedback\022&\n\rtest_feedba"
+  "ck\030\001 \001(\0132\r.TestFeedbackH\000\022&\n\rcall_feedba"
+  "ck\030\002 \001(\0132\r.CallFeedbackH\000\022(\n\016value_feedb"
+  "ack\030\003 \001(\0132\016.ValueFeedbackH\000B\n\n\010feedback\032"
+  "D\n\nTypesEntry\022\013\n\003key\030\001 \001(\003\022%\n\005value\030\002 \001("
+  "\0132\026.TypeFeedback.Feedback:\0028\001\".\n\017Feedbac"
+  "kRequest\022\033\n\010function\030\001 \001(\0132\t.Function\"C\n"
+  "\rPackageSource\022\022\n\010r_mirror\030\002 \001(\tH\000\022\024\n\ngi"
+  "thub_url\030\003 \001(\tH\000B\010\n\006source\"{\n\007Package\022\014\n"
+  "\004name\030\001 \001(\t\022\031\n\007version\030\002 \001(\0132\010.Version\022\027"
+  "\n\017function_hashes\030\004 \003(\014\022#\n\006source\030\005 \001(\0132"
+  "\016.PackageSourceH\000\210\001\001B\t\n\007_source\"\036\n\016Packa"
+  "geRequest\022\014\n\004hash\030\001 \001(\014*#\n\004Tier\022\014\n\010BASEL"
+  "INE\020\000\022\r\n\tOPTIMIZED\020\001*@\n\013TestLattice\022\010\n\004B"
+  "OTH\020\000\022\r\n\tONLY_TRUE\020\001\022\016\n\nONLY_FALSE\020\002\022\010\n\004"
+  "NONE\020\003*&\n\004Type\022\007\n\003ANY\020\000\022\013\n\007INTEGER\020\001\022\010\n\004"
+  "REAL\020\002B\023\n\021org.prlprg.serverb\006proto3"
+  ;
+static ::_pbi::once_flag descriptor_table_messages_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_messages_2eproto = {
+    false, false, 2235, descriptor_table_protodef_messages_2eproto,
+    "messages.proto",
+    &descriptor_table_messages_2eproto_once, nullptr, 0, 27,
+    schemas, file_default_instances, TableStruct_messages_2eproto::offsets,
+    file_level_metadata_messages_2eproto, file_level_enum_descriptors_messages_2eproto,
+    file_level_service_descriptors_messages_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_messages_2eproto_getter() {
+  return &descriptor_table_messages_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2eproto(&descriptor_table_messages_2eproto);
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Tier_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2eproto);
+  return file_level_enum_descriptors_messages_2eproto[0];
+}
+bool Tier_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TestLattice_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2eproto);
+  return file_level_enum_descriptors_messages_2eproto[1];
+}
+bool TestLattice_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2eproto);
+  return file_level_enum_descriptors_messages_2eproto[2];
+}
+bool Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+class Version::_Internal {
+ public:
+};
+
+Version::Version(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:Version)
+}
+Version::Version(const Version& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Version* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.major_){}
+    , decltype(_impl_.minor_){}
+    , decltype(_impl_.patch_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.major_, &from._impl_.major_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.patch_) -
+    reinterpret_cast<char*>(&_impl_.major_)) + sizeof(_impl_.patch_));
+  // @@protoc_insertion_point(copy_constructor:Version)
+}
+
+inline void Version::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.major_){0}
+    , decltype(_impl_.minor_){0}
+    , decltype(_impl_.patch_){0}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Version::~Version() {
+  // @@protoc_insertion_point(destructor:Version)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Version::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Version::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Version::Clear() {
+// @@protoc_insertion_point(message_clear_start:Version)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.major_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.patch_) -
+      reinterpret_cast<char*>(&_impl_.major_)) + sizeof(_impl_.patch_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Version::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 major = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.major_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 minor = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _impl_.minor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 patch = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _impl_.patch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Version::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Version)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 major = 1;
+  if (this->_internal_major() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_major(), target);
+  }
+
+  // int32 minor = 2;
+  if (this->_internal_minor() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_minor(), target);
+  }
+
+  // int32 patch = 3;
+  if (this->_internal_patch() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_patch(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Version)
+  return target;
+}
+
+size_t Version::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Version)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 major = 1;
+  if (this->_internal_major() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_major());
+  }
+
+  // int32 minor = 2;
+  if (this->_internal_minor() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_minor());
+  }
+
+  // int32 patch = 3;
+  if (this->_internal_patch() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_patch());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Version::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Version::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Version::GetClassData() const { return &_class_data_; }
+
+
+void Version::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Version*>(&to_msg);
+  auto& from = static_cast<const Version&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Version)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_major() != 0) {
+    _this->_internal_set_major(from._internal_major());
+  }
+  if (from._internal_minor() != 0) {
+    _this->_internal_set_minor(from._internal_minor());
+  }
+  if (from._internal_patch() != 0) {
+    _this->_internal_set_patch(from._internal_patch());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Version::CopyFrom(const Version& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Version)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Version::IsInitialized() const {
+  return true;
+}
+
+void Version::InternalSwap(Version* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Version, _impl_.patch_)
+      + sizeof(Version::_impl_.patch_)
+      - PROTOBUF_FIELD_OFFSET(Version, _impl_.major_)>(
+          reinterpret_cast<char*>(&_impl_.major_),
+          reinterpret_cast<char*>(&other->_impl_.major_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Version::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[0]);
+}
+
+// ===================================================================
+
+class InitRequest::_Internal {
+ public:
+  static const ::Version& rsh_version(const InitRequest* msg);
+  static const ::Version& r_version(const InitRequest* msg);
+};
+
+const ::Version&
+InitRequest::_Internal::rsh_version(const InitRequest* msg) {
+  return *msg->_impl_.rsh_version_;
+}
+const ::Version&
+InitRequest::_Internal::r_version(const InitRequest* msg) {
+  return *msg->_impl_.r_version_;
+}
+InitRequest::InitRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:InitRequest)
+}
+InitRequest::InitRequest(const InitRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  InitRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.package_hash_){from._impl_.package_hash_}
+    , decltype(_impl_.platform_){}
+    , decltype(_impl_.rsh_version_){nullptr}
+    , decltype(_impl_.r_version_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.platform_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.platform_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_platform().empty()) {
+    _this->_impl_.platform_.Set(from._internal_platform(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_rsh_version()) {
+    _this->_impl_.rsh_version_ = new ::Version(*from._impl_.rsh_version_);
+  }
+  if (from._internal_has_r_version()) {
+    _this->_impl_.r_version_ = new ::Version(*from._impl_.r_version_);
+  }
+  // @@protoc_insertion_point(copy_constructor:InitRequest)
+}
+
+inline void InitRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.package_hash_){arena}
+    , decltype(_impl_.platform_){}
+    , decltype(_impl_.rsh_version_){nullptr}
+    , decltype(_impl_.r_version_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.platform_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.platform_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+InitRequest::~InitRequest() {
+  // @@protoc_insertion_point(destructor:InitRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void InitRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.package_hash_.~RepeatedPtrField();
+  _impl_.platform_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.rsh_version_;
+  if (this != internal_default_instance()) delete _impl_.r_version_;
+}
+
+void InitRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void InitRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:InitRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.package_hash_.Clear();
+  _impl_.platform_.ClearToEmpty();
+  if (GetArenaForAllocation() == nullptr && _impl_.rsh_version_ != nullptr) {
+    delete _impl_.rsh_version_;
+  }
+  _impl_.rsh_version_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && _impl_.r_version_ != nullptr) {
+    delete _impl_.r_version_;
+  }
+  _impl_.r_version_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* InitRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .Version Rsh_version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_rsh_version(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .Version R_version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_r_version(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string platform = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_platform();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          CHK_(::_pbi::VerifyUTF8(str, "InitRequest.platform"));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated bytes package_hash = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_package_hash();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* InitRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:InitRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .Version Rsh_version = 1;
+  if (this->_internal_has_rsh_version()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::rsh_version(this),
+        _Internal::rsh_version(this).GetCachedSize(), target, stream);
+  }
+
+  // .Version R_version = 2;
+  if (this->_internal_has_r_version()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::r_version(this),
+        _Internal::r_version(this).GetCachedSize(), target, stream);
+  }
+
+  // string platform = 3;
+  if (!this->_internal_platform().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_platform().data(), static_cast<int>(this->_internal_platform().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "InitRequest.platform");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_platform(), target);
+  }
+
+  // repeated bytes package_hash = 4;
+  for (int i = 0, n = this->_internal_package_hash_size(); i < n; i++) {
+    const auto& s = this->_internal_package_hash(i);
+    target = stream->WriteBytes(4, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:InitRequest)
+  return target;
+}
+
+size_t InitRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:InitRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated bytes package_hash = 4;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.package_hash_.size());
+  for (int i = 0, n = _impl_.package_hash_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      _impl_.package_hash_.Get(i));
+  }
+
+  // string platform = 3;
+  if (!this->_internal_platform().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_platform());
+  }
+
+  // .Version Rsh_version = 1;
+  if (this->_internal_has_rsh_version()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.rsh_version_);
+  }
+
+  // .Version R_version = 2;
+  if (this->_internal_has_r_version()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.r_version_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InitRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    InitRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InitRequest::GetClassData() const { return &_class_data_; }
+
+
+void InitRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<InitRequest*>(&to_msg);
+  auto& from = static_cast<const InitRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:InitRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.package_hash_.MergeFrom(from._impl_.package_hash_);
+  if (!from._internal_platform().empty()) {
+    _this->_internal_set_platform(from._internal_platform());
+  }
+  if (from._internal_has_rsh_version()) {
+    _this->_internal_mutable_rsh_version()->::Version::MergeFrom(
+        from._internal_rsh_version());
+  }
+  if (from._internal_has_r_version()) {
+    _this->_internal_mutable_r_version()->::Version::MergeFrom(
+        from._internal_r_version());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void InitRequest::CopyFrom(const InitRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:InitRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InitRequest::IsInitialized() const {
+  return true;
+}
+
+void InitRequest::InternalSwap(InitRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.package_hash_.InternalSwap(&other->_impl_.package_hash_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.platform_, lhs_arena,
+      &other->_impl_.platform_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(InitRequest, _impl_.r_version_)
+      + sizeof(InitRequest::_impl_.r_version_)
+      - PROTOBUF_FIELD_OFFSET(InitRequest, _impl_.rsh_version_)>(
+          reinterpret_cast<char*>(&_impl_.rsh_version_),
+          reinterpret_cast<char*>(&other->_impl_.rsh_version_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata InitRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[1]);
+}
+
+// ===================================================================
+
+class InitResponse::_Internal {
+ public:
+};
+
+InitResponse::InitResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:InitResponse)
+}
+InitResponse::InitResponse(const InitResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  InitResponse* const _this = this; (void)_this;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:InitResponse)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InitResponse::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InitResponse::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata InitResponse::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[2]);
+}
+
+// ===================================================================
+
+class CompileRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CompileRequest>()._impl_._has_bits_);
+  static const ::Function& function(const CompileRequest* msg);
+  static void set_has_tier(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_optimization_level(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::Context& context(const CompileRequest* msg);
+  static void set_has_context(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::Environment& environment(const CompileRequest* msg);
+  static void set_has_environment(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::Function&
+CompileRequest::_Internal::function(const CompileRequest* msg) {
+  return *msg->_impl_.function_;
+}
+const ::Context&
+CompileRequest::_Internal::context(const CompileRequest* msg) {
+  return *msg->_impl_.context_;
+}
+const ::Environment&
+CompileRequest::_Internal::environment(const CompileRequest* msg) {
+  return *msg->_impl_.environment_;
+}
+CompileRequest::CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CompileRequest)
+}
+CompileRequest::CompileRequest(const CompileRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CompileRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.function_){nullptr}
+    , decltype(_impl_.context_){nullptr}
+    , decltype(_impl_.environment_){nullptr}
+    , decltype(_impl_.tier_){}
+    , decltype(_impl_.optimization_level_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_function()) {
+    _this->_impl_.function_ = new ::Function(*from._impl_.function_);
+  }
+  if (from._internal_has_context()) {
+    _this->_impl_.context_ = new ::Context(*from._impl_.context_);
+  }
+  if (from._internal_has_environment()) {
+    _this->_impl_.environment_ = new ::Environment(*from._impl_.environment_);
+  }
+  ::memcpy(&_impl_.tier_, &from._impl_.tier_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.optimization_level_) -
+    reinterpret_cast<char*>(&_impl_.tier_)) + sizeof(_impl_.optimization_level_));
+  // @@protoc_insertion_point(copy_constructor:CompileRequest)
+}
+
+inline void CompileRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.function_){nullptr}
+    , decltype(_impl_.context_){nullptr}
+    , decltype(_impl_.environment_){nullptr}
+    , decltype(_impl_.tier_){0}
+    , decltype(_impl_.optimization_level_){0}
+  };
+}
+
+CompileRequest::~CompileRequest() {
+  // @@protoc_insertion_point(destructor:CompileRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CompileRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.function_;
+  if (this != internal_default_instance()) delete _impl_.context_;
+  if (this != internal_default_instance()) delete _impl_.environment_;
+}
+
+void CompileRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CompileRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:CompileRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && _impl_.function_ != nullptr) {
+    delete _impl_.function_;
+  }
+  _impl_.function_ = nullptr;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.context_ != nullptr);
+      _impl_.context_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.environment_ != nullptr);
+      _impl_.environment_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.tier_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.optimization_level_) -
+        reinterpret_cast<char*>(&_impl_.tier_)) + sizeof(_impl_.optimization_level_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .Function function = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .Tier tier = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_tier(static_cast<::Tier>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 optimization_level = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_optimization_level(&has_bits);
+          _impl_.optimization_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .Context context = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_context(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .Environment environment = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_environment(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CompileRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CompileRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .Function function = 2;
+  if (this->_internal_has_function()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::function(this),
+        _Internal::function(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .Tier tier = 4;
+  if (_internal_has_tier()) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_tier(), target);
+  }
+
+  // optional int32 optimization_level = 5;
+  if (_internal_has_optimization_level()) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_optimization_level(), target);
+  }
+
+  // optional .Context context = 6;
+  if (_internal_has_context()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::context(this),
+        _Internal::context(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .Environment environment = 7;
+  if (_internal_has_environment()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::environment(this),
+        _Internal::environment(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CompileRequest)
+  return target;
+}
+
+size_t CompileRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CompileRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .Function function = 2;
+  if (this->_internal_has_function()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.function_);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional .Context context = 6;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.context_);
+    }
+
+    // optional .Environment environment = 7;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.environment_);
+    }
+
+    // optional .Tier tier = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_tier());
+    }
+
+    // optional int32 optimization_level = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_optimization_level());
+    }
+
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompileRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CompileRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileRequest::GetClassData() const { return &_class_data_; }
+
+
+void CompileRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CompileRequest*>(&to_msg);
+  auto& from = static_cast<const CompileRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CompileRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_function()) {
+    _this->_internal_mutable_function()->::Function::MergeFrom(
+        from._internal_function());
+  }
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_context()->::Context::MergeFrom(
+          from._internal_context());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_environment()->::Environment::MergeFrom(
+          from._internal_environment());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.tier_ = from._impl_.tier_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.optimization_level_ = from._impl_.optimization_level_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CompileRequest::CopyFrom(const CompileRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CompileRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CompileRequest::IsInitialized() const {
+  return true;
+}
+
+void CompileRequest::InternalSwap(CompileRequest* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CompileRequest, _impl_.optimization_level_)
+      + sizeof(CompileRequest::_impl_.optimization_level_)
+      - PROTOBUF_FIELD_OFFSET(CompileRequest, _impl_.function_)>(
+          reinterpret_cast<char*>(&_impl_.function_),
+          reinterpret_cast<char*>(&other->_impl_.function_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CompileRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[3]);
+}
+
+// ===================================================================
+
+class CompileResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<CompileResponse>()._impl_._has_bits_);
+  static void set_has_code(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_constant_pool(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+CompileResponse::CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CompileResponse)
+}
+CompileResponse::CompileResponse(const CompileResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CompileResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.hash_){}
+    , decltype(_impl_.code_){}
+    , decltype(_impl_.constant_pool_){}
+    , decltype(_impl_.tier_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_hash().empty()) {
+    _this->_impl_.hash_.Set(from._internal_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.code_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.code_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_code()) {
+    _this->_impl_.code_.Set(from._internal_code(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.constant_pool_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_constant_pool()) {
+    _this->_impl_.constant_pool_.Set(from._internal_constant_pool(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.tier_ = from._impl_.tier_;
+  // @@protoc_insertion_point(copy_constructor:CompileResponse)
+}
+
+inline void CompileResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.hash_){}
+    , decltype(_impl_.code_){}
+    , decltype(_impl_.constant_pool_){}
+    , decltype(_impl_.tier_){0}
+  };
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.code_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.code_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.constant_pool_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+CompileResponse::~CompileResponse() {
+  // @@protoc_insertion_point(destructor:CompileResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CompileResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.hash_.Destroy();
+  _impl_.code_.Destroy();
+  _impl_.constant_pool_.Destroy();
+}
+
+void CompileResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CompileResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:CompileResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.hash_.ClearToEmpty();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.code_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.constant_pool_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.tier_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .Tier tier = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_tier(static_cast<::Tier>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes code = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_code();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes constant_pool = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_constant_pool();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CompileResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CompileResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_hash(), target);
+  }
+
+  // .Tier tier = 2;
+  if (this->_internal_tier() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_tier(), target);
+  }
+
+  // optional bytes code = 3;
+  if (_internal_has_code()) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_code(), target);
+  }
+
+  // optional bytes constant_pool = 4;
+  if (_internal_has_constant_pool()) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_constant_pool(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CompileResponse)
+  return target;
+}
+
+size_t CompileResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CompileResponse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_hash());
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes code = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_code());
+    }
+
+    // optional bytes constant_pool = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_constant_pool());
+    }
+
+  }
+  // .Tier tier = 2;
+  if (this->_internal_tier() != 0) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_tier());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompileResponse::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CompileResponse::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileResponse::GetClassData() const { return &_class_data_; }
+
+
+void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CompileResponse*>(&to_msg);
+  auto& from = static_cast<const CompileResponse&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CompileResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_hash().empty()) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_code(from._internal_code());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_constant_pool(from._internal_constant_pool());
+    }
+  }
+  if (from._internal_tier() != 0) {
+    _this->_internal_set_tier(from._internal_tier());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CompileResponse::CopyFrom(const CompileResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CompileResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CompileResponse::IsInitialized() const {
+  return true;
+}
+
+void CompileResponse::InternalSwap(CompileResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hash_, lhs_arena,
+      &other->_impl_.hash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.code_, lhs_arena,
+      &other->_impl_.code_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.constant_pool_, lhs_arena,
+      &other->_impl_.constant_pool_, rhs_arena
+  );
+  swap(_impl_.tier_, other->_impl_.tier_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CompileResponse::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[4]);
+}
+
+// ===================================================================
+
+class Function::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Function>()._impl_._has_bits_);
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+Function::Function(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:Function)
+}
+Function::Function(const Function& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Function* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.package_hash_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.hash_){}
+    , decltype(_impl_.body_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.package_hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.package_hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_package_hash().empty()) {
+    _this->_impl_.package_hash_.Set(from._internal_package_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_hash().empty()) {
+    _this->_impl_.hash_.Set(from._internal_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_body()) {
+    _this->_impl_.body_.Set(from._internal_body(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:Function)
+}
+
+inline void Function::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.package_hash_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.hash_){}
+    , decltype(_impl_.body_){}
+  };
+  _impl_.package_hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.package_hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Function::~Function() {
+  // @@protoc_insertion_point(destructor:Function)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Function::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.package_hash_.Destroy();
+  _impl_.name_.Destroy();
+  _impl_.hash_.Destroy();
+  _impl_.body_.Destroy();
+}
+
+void Function::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Function::Clear() {
+// @@protoc_insertion_point(message_clear_start:Function)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.package_hash_.ClearToEmpty();
+  _impl_.name_.ClearToEmpty();
+  _impl_.hash_.ClearToEmpty();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.body_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Function::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes package_hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_package_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string name = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          CHK_(::_pbi::VerifyUTF8(str, "Function.name"));
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes hash = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes body = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_body();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Function::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Function)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes package_hash = 1;
+  if (!this->_internal_package_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_package_hash(), target);
+  }
+
+  // string name = 2;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "Function.name");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_name(), target);
+  }
+
+  // bytes hash = 3;
+  if (!this->_internal_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_hash(), target);
+  }
+
+  // optional bytes body = 4;
+  if (_internal_has_body()) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_body(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Function)
+  return target;
+}
+
+size_t Function::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Function)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes package_hash = 1;
+  if (!this->_internal_package_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_package_hash());
+  }
+
+  // string name = 2;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // bytes hash = 3;
+  if (!this->_internal_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_hash());
+  }
+
+  // optional bytes body = 4;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_body());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Function::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Function::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Function::GetClassData() const { return &_class_data_; }
+
+
+void Function::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Function*>(&to_msg);
+  auto& from = static_cast<const Function&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Function)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_package_hash().empty()) {
+    _this->_internal_set_package_hash(from._internal_package_hash());
+  }
+  if (!from._internal_name().empty()) {
+    _this->_internal_set_name(from._internal_name());
+  }
+  if (!from._internal_hash().empty()) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
+  if (from._internal_has_body()) {
+    _this->_internal_set_body(from._internal_body());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Function::CopyFrom(const Function& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Function)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Function::IsInitialized() const {
+  return true;
+}
+
+void Function::InternalSwap(Function* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.package_hash_, lhs_arena,
+      &other->_impl_.package_hash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hash_, lhs_arena,
+      &other->_impl_.hash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.body_, lhs_arena,
+      &other->_impl_.body_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Function::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[5]);
+}
+
+// ===================================================================
+
+class FunctionRequest::_Internal {
+ public:
+};
+
+FunctionRequest::FunctionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:FunctionRequest)
+}
+FunctionRequest::FunctionRequest(const FunctionRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  FunctionRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_hash().empty()) {
+    _this->_impl_.hash_.Set(from._internal_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:FunctionRequest)
+}
+
+inline void FunctionRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+FunctionRequest::~FunctionRequest() {
+  // @@protoc_insertion_point(destructor:FunctionRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void FunctionRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.hash_.Destroy();
+}
+
+void FunctionRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void FunctionRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:FunctionRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.hash_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:FunctionRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_hash(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:FunctionRequest)
+  return target;
+}
+
+size_t FunctionRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:FunctionRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_hash());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    FunctionRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionRequest::GetClassData() const { return &_class_data_; }
+
+
+void FunctionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<FunctionRequest*>(&to_msg);
+  auto& from = static_cast<const FunctionRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:FunctionRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_hash().empty()) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionRequest::CopyFrom(const FunctionRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:FunctionRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionRequest::IsInitialized() const {
+  return true;
+}
+
+void FunctionRequest::InternalSwap(FunctionRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hash_, lhs_arena,
+      &other->_impl_.hash_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[6]);
+}
+
+// ===================================================================
+
+Environment_ValuesEntry_DoNotUse::Environment_ValuesEntry_DoNotUse() {}
+Environment_ValuesEntry_DoNotUse::Environment_ValuesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+    : SuperType(arena) {}
+void Environment_ValuesEntry_DoNotUse::MergeFrom(const Environment_ValuesEntry_DoNotUse& other) {
+  MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata Environment_ValuesEntry_DoNotUse::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[7]);
+}
+
+// ===================================================================
+
+class Environment::_Internal {
+ public:
+};
+
+Environment::Environment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  if (arena != nullptr && !is_message_owned) {
+    arena->OwnCustomDestructor(this, &Environment::ArenaDtor);
+  }
+  // @@protoc_insertion_point(arena_constructor:Environment)
+}
+Environment::Environment(const Environment& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Environment* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      /*decltype(_impl_.values_)*/{}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.values_.MergeFrom(from._impl_.values_);
+  // @@protoc_insertion_point(copy_constructor:Environment)
+}
+
+inline void Environment::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      /*decltype(_impl_.values_)*/{::_pbi::ArenaInitialized(), arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Environment::~Environment() {
+  // @@protoc_insertion_point(destructor:Environment)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    ArenaDtor(this);
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Environment::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.values_.Destruct();
+  _impl_.values_.~MapField();
+}
+
+void Environment::ArenaDtor(void* object) {
+  Environment* _this = reinterpret_cast< Environment* >(object);
+  _this->_impl_.values_.Destruct();
+}
+void Environment::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Environment::Clear() {
+// @@protoc_insertion_point(message_clear_start:Environment)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.values_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Environment::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // map<string, bytes> values = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(&_impl_.values_, ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Environment::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Environment)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // map<string, bytes> values = 1;
+  if (!this->_internal_values().empty()) {
+    using MapType = ::_pb::Map<std::string, std::string>;
+    using WireHelper = Environment_ValuesEntry_DoNotUse::Funcs;
+    const auto& map_field = this->_internal_values();
+    auto check_utf8 = [](const MapType::value_type& entry) {
+      (void)entry;
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+        entry.first.data(), static_cast<int>(entry.first.length()),
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+        "Environment.ValuesEntry.key");
+    };
+
+    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
+      for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
+        target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
+        check_utf8(entry);
+      }
+    } else {
+      for (const auto& entry : map_field) {
+        target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
+        check_utf8(entry);
+      }
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Environment)
+  return target;
+}
+
+size_t Environment::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Environment)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // map<string, bytes> values = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_values_size());
+  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
+      it = this->_internal_values().begin();
+      it != this->_internal_values().end(); ++it) {
+    total_size += Environment_ValuesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Environment::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Environment::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Environment::GetClassData() const { return &_class_data_; }
+
+
+void Environment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Environment*>(&to_msg);
+  auto& from = static_cast<const Environment&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Environment)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.values_.MergeFrom(from._impl_.values_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Environment::CopyFrom(const Environment& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Environment)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Environment::IsInitialized() const {
+  return true;
+}
+
+void Environment::InternalSwap(Environment* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.values_.InternalSwap(&other->_impl_.values_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Environment::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[8]);
+}
+
+// ===================================================================
+
+class ValueRequest::_Internal {
+ public:
+};
+
+ValueRequest::ValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:ValueRequest)
+}
+ValueRequest::ValueRequest(const ValueRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ValueRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){from._impl_.hash_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:ValueRequest)
+}
+
+inline void ValueRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+ValueRequest::~ValueRequest() {
+  // @@protoc_insertion_point(destructor:ValueRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ValueRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.hash_.~RepeatedPtrField();
+}
+
+void ValueRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ValueRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:ValueRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.hash_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated bytes hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_hash();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ValueRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:ValueRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated bytes hash = 1;
+  for (int i = 0, n = this->_internal_hash_size(); i < n; i++) {
+    const auto& s = this->_internal_hash(i);
+    target = stream->WriteBytes(1, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:ValueRequest)
+  return target;
+}
+
+size_t ValueRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:ValueRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated bytes hash = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.hash_.size());
+  for (int i = 0, n = _impl_.hash_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      _impl_.hash_.Get(i));
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ValueRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ValueRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ValueRequest::GetClassData() const { return &_class_data_; }
+
+
+void ValueRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ValueRequest*>(&to_msg);
+  auto& from = static_cast<const ValueRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:ValueRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.hash_.MergeFrom(from._impl_.hash_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ValueRequest::CopyFrom(const ValueRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:ValueRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ValueRequest::IsInitialized() const {
+  return true;
+}
+
+void ValueRequest::InternalSwap(ValueRequest* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.hash_.InternalSwap(&other->_impl_.hash_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ValueRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[9]);
+}
+
+// ===================================================================
+
+class Value::_Internal {
+ public:
+};
+
+Value::Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:Value)
+}
+Value::Value(const Value& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Value* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){}
+    , decltype(_impl_.value_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_hash().empty()) {
+    _this->_impl_.hash_.Set(from._internal_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_value().empty()) {
+    _this->_impl_.value_.Set(from._internal_value(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:Value)
+}
+
+inline void Value::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){}
+    , decltype(_impl_.value_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Value::~Value() {
+  // @@protoc_insertion_point(destructor:Value)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Value::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.hash_.Destroy();
+  _impl_.value_.Destroy();
+}
+
+void Value::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Value::Clear() {
+// @@protoc_insertion_point(message_clear_start:Value)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.hash_.ClearToEmpty();
+  _impl_.value_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_value();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Value::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Value)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_hash(), target);
+  }
+
+  // bytes value = 2;
+  if (!this->_internal_value().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_value(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Value)
+  return target;
+}
+
+size_t Value::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Value)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_hash());
+  }
+
+  // bytes value = 2;
+  if (!this->_internal_value().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_value());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Value::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Value::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Value::GetClassData() const { return &_class_data_; }
+
+
+void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Value*>(&to_msg);
+  auto& from = static_cast<const Value&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Value)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_hash().empty()) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
+  if (!from._internal_value().empty()) {
+    _this->_internal_set_value(from._internal_value());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Value::CopyFrom(const Value& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Value)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Value::IsInitialized() const {
+  return true;
+}
+
+void Value::InternalSwap(Value* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hash_, lhs_arena,
+      &other->_impl_.hash_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.value_, lhs_arena,
+      &other->_impl_.value_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Value::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[10]);
+}
+
+// ===================================================================
+
+class Values::_Internal {
+ public:
+};
+
+Values::Values(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:Values)
+}
+Values::Values(const Values& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Values* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.values_){from._impl_.values_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:Values)
+}
+
+inline void Values::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.values_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Values::~Values() {
+  // @@protoc_insertion_point(destructor:Values)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Values::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.values_.~RepeatedPtrField();
+}
+
+void Values::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Values::Clear() {
+// @@protoc_insertion_point(message_clear_start:Values)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.values_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Values::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .Value values = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Values::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Values)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .Value values = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_values_size()); i < n; i++) {
+    const auto& repfield = this->_internal_values(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Values)
+  return target;
+}
+
+size_t Values::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Values)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .Value values = 1;
+  total_size += 1UL * this->_internal_values_size();
+  for (const auto& msg : this->_impl_.values_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Values::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Values::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Values::GetClassData() const { return &_class_data_; }
+
+
+void Values::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Values*>(&to_msg);
+  auto& from = static_cast<const Values&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Values)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.values_.MergeFrom(from._impl_.values_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Values::CopyFrom(const Values& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Values)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Values::IsInitialized() const {
+  return true;
+}
+
+void Values::InternalSwap(Values* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.values_.InternalSwap(&other->_impl_.values_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Values::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[11]);
+}
+
+// ===================================================================
+
+class Empty::_Internal {
+ public:
+};
+
+Empty::Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:Empty)
+}
+Empty::Empty(const Empty& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  Empty* const _this = this; (void)_this;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:Empty)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Empty::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Empty::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata Empty::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[12]);
+}
+
+// ===================================================================
+
+class CallContext::_Internal {
+ public:
+};
+
+CallContext::CallContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CallContext)
+}
+CallContext::CallContext(const CallContext& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CallContext* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.args_statically_matched_){}
+    , decltype(_impl_.correct_number_of_args_){}
+    , decltype(_impl_.correct_order_of_args_){}
+    , decltype(_impl_.no_missing_args_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.args_statically_matched_, &from._impl_.args_statically_matched_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.no_missing_args_) -
+    reinterpret_cast<char*>(&_impl_.args_statically_matched_)) + sizeof(_impl_.no_missing_args_));
+  // @@protoc_insertion_point(copy_constructor:CallContext)
+}
+
+inline void CallContext::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.args_statically_matched_){false}
+    , decltype(_impl_.correct_number_of_args_){false}
+    , decltype(_impl_.correct_order_of_args_){false}
+    , decltype(_impl_.no_missing_args_){false}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+CallContext::~CallContext() {
+  // @@protoc_insertion_point(destructor:CallContext)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CallContext::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void CallContext::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CallContext::Clear() {
+// @@protoc_insertion_point(message_clear_start:CallContext)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.args_statically_matched_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.no_missing_args_) -
+      reinterpret_cast<char*>(&_impl_.args_statically_matched_)) + sizeof(_impl_.no_missing_args_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CallContext::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bool args_statically_matched = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.args_statically_matched_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool correct_number_of_args = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _impl_.correct_number_of_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool correct_order_of_args = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _impl_.correct_order_of_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool no_missing_args = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _impl_.no_missing_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CallContext::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CallContext)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bool args_statically_matched = 1;
+  if (this->_internal_args_statically_matched() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_args_statically_matched(), target);
+  }
+
+  // bool correct_number_of_args = 2;
+  if (this->_internal_correct_number_of_args() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_correct_number_of_args(), target);
+  }
+
+  // bool correct_order_of_args = 3;
+  if (this->_internal_correct_order_of_args() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_correct_order_of_args(), target);
+  }
+
+  // bool no_missing_args = 4;
+  if (this->_internal_no_missing_args() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_no_missing_args(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CallContext)
+  return target;
+}
+
+size_t CallContext::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CallContext)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bool args_statically_matched = 1;
+  if (this->_internal_args_statically_matched() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool correct_number_of_args = 2;
+  if (this->_internal_correct_number_of_args() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool correct_order_of_args = 3;
+  if (this->_internal_correct_order_of_args() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool no_missing_args = 4;
+  if (this->_internal_no_missing_args() != 0) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CallContext::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CallContext::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CallContext::GetClassData() const { return &_class_data_; }
+
+
+void CallContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CallContext*>(&to_msg);
+  auto& from = static_cast<const CallContext&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CallContext)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_args_statically_matched() != 0) {
+    _this->_internal_set_args_statically_matched(from._internal_args_statically_matched());
+  }
+  if (from._internal_correct_number_of_args() != 0) {
+    _this->_internal_set_correct_number_of_args(from._internal_correct_number_of_args());
+  }
+  if (from._internal_correct_order_of_args() != 0) {
+    _this->_internal_set_correct_order_of_args(from._internal_correct_order_of_args());
+  }
+  if (from._internal_no_missing_args() != 0) {
+    _this->_internal_set_no_missing_args(from._internal_no_missing_args());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CallContext::CopyFrom(const CallContext& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CallContext)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CallContext::IsInitialized() const {
+  return true;
+}
+
+void CallContext::InternalSwap(CallContext* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CallContext, _impl_.no_missing_args_)
+      + sizeof(CallContext::_impl_.no_missing_args_)
+      - PROTOBUF_FIELD_OFFSET(CallContext, _impl_.args_statically_matched_)>(
+          reinterpret_cast<char*>(&_impl_.args_statically_matched_),
+          reinterpret_cast<char*>(&other->_impl_.args_statically_matched_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CallContext::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[13]);
+}
+
+// ===================================================================
+
+class ArgumentContext::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ArgumentContext>()._impl_._has_bits_);
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ArgumentContext::ArgumentContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:ArgumentContext)
+}
+ArgumentContext::ArgumentContext(const ArgumentContext& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ArgumentContext* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.eager_){}
+    , decltype(_impl_.reflection_){}
+    , decltype(_impl_.object_){}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.eager_, &from._impl_.eager_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
+    reinterpret_cast<char*>(&_impl_.eager_)) + sizeof(_impl_.type_));
+  // @@protoc_insertion_point(copy_constructor:ArgumentContext)
+}
+
+inline void ArgumentContext::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.eager_){false}
+    , decltype(_impl_.reflection_){false}
+    , decltype(_impl_.object_){false}
+    , decltype(_impl_.type_){0}
+  };
+}
+
+ArgumentContext::~ArgumentContext() {
+  // @@protoc_insertion_point(destructor:ArgumentContext)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ArgumentContext::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ArgumentContext::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ArgumentContext::Clear() {
+// @@protoc_insertion_point(message_clear_start:ArgumentContext)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.eager_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.object_) -
+      reinterpret_cast<char*>(&_impl_.eager_)) + sizeof(_impl_.object_));
+  _impl_.type_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ArgumentContext::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bool eager = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.eager_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool reflection = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _impl_.reflection_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool object = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _impl_.object_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .Type type = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_type(static_cast<::Type>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ArgumentContext::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:ArgumentContext)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bool eager = 1;
+  if (this->_internal_eager() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_eager(), target);
+  }
+
+  // bool reflection = 2;
+  if (this->_internal_reflection() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_reflection(), target);
+  }
+
+  // bool object = 3;
+  if (this->_internal_object() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_object(), target);
+  }
+
+  // optional .Type type = 4;
+  if (_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:ArgumentContext)
+  return target;
+}
+
+size_t ArgumentContext::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:ArgumentContext)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bool eager = 1;
+  if (this->_internal_eager() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool reflection = 2;
+  if (this->_internal_reflection() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool object = 3;
+  if (this->_internal_object() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // optional .Type type = 4;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ArgumentContext::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ArgumentContext::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ArgumentContext::GetClassData() const { return &_class_data_; }
+
+
+void ArgumentContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ArgumentContext*>(&to_msg);
+  auto& from = static_cast<const ArgumentContext&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:ArgumentContext)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_eager() != 0) {
+    _this->_internal_set_eager(from._internal_eager());
+  }
+  if (from._internal_reflection() != 0) {
+    _this->_internal_set_reflection(from._internal_reflection());
+  }
+  if (from._internal_object() != 0) {
+    _this->_internal_set_object(from._internal_object());
+  }
+  if (from._internal_has_type()) {
+    _this->_internal_set_type(from._internal_type());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ArgumentContext::CopyFrom(const ArgumentContext& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:ArgumentContext)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ArgumentContext::IsInitialized() const {
+  return true;
+}
+
+void ArgumentContext::InternalSwap(ArgumentContext* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ArgumentContext, _impl_.type_)
+      + sizeof(ArgumentContext::_impl_.type_)
+      - PROTOBUF_FIELD_OFFSET(ArgumentContext, _impl_.eager_)>(
+          reinterpret_cast<char*>(&_impl_.eager_),
+          reinterpret_cast<char*>(&other->_impl_.eager_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ArgumentContext::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[14]);
+}
+
+// ===================================================================
+
+class Context::_Internal {
+ public:
+  static const ::CallContext& call_context(const Context* msg);
+};
+
+const ::CallContext&
+Context::_Internal::call_context(const Context* msg) {
+  return *msg->_impl_.call_context_;
+}
+Context::Context(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:Context)
+}
+Context::Context(const Context& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Context* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.argument_context_){from._impl_.argument_context_}
+    , decltype(_impl_.call_context_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_call_context()) {
+    _this->_impl_.call_context_ = new ::CallContext(*from._impl_.call_context_);
+  }
+  // @@protoc_insertion_point(copy_constructor:Context)
+}
+
+inline void Context::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.argument_context_){arena}
+    , decltype(_impl_.call_context_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+Context::~Context() {
+  // @@protoc_insertion_point(destructor:Context)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Context::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.argument_context_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.call_context_;
+}
+
+void Context::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Context::Clear() {
+// @@protoc_insertion_point(message_clear_start:Context)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.argument_context_.Clear();
+  if (GetArenaForAllocation() == nullptr && _impl_.call_context_ != nullptr) {
+    delete _impl_.call_context_;
+  }
+  _impl_.call_context_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Context::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .CallContext call_context = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_call_context(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .ArgumentContext argument_context = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_argument_context(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Context::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Context)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .CallContext call_context = 1;
+  if (this->_internal_has_call_context()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::call_context(this),
+        _Internal::call_context(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .ArgumentContext argument_context = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_argument_context_size()); i < n; i++) {
+    const auto& repfield = this->_internal_argument_context(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Context)
+  return target;
+}
+
+size_t Context::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Context)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .ArgumentContext argument_context = 2;
+  total_size += 1UL * this->_internal_argument_context_size();
+  for (const auto& msg : this->_impl_.argument_context_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .CallContext call_context = 1;
+  if (this->_internal_has_call_context()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.call_context_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Context::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Context::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Context::GetClassData() const { return &_class_data_; }
+
+
+void Context::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Context*>(&to_msg);
+  auto& from = static_cast<const Context&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Context)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.argument_context_.MergeFrom(from._impl_.argument_context_);
+  if (from._internal_has_call_context()) {
+    _this->_internal_mutable_call_context()->::CallContext::MergeFrom(
+        from._internal_call_context());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Context::CopyFrom(const Context& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Context)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Context::IsInitialized() const {
+  return true;
+}
+
+void Context::InternalSwap(Context* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.argument_context_.InternalSwap(&other->_impl_.argument_context_);
+  swap(_impl_.call_context_, other->_impl_.call_context_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Context::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[15]);
+}
+
+// ===================================================================
+
+class ContextRequest::_Internal {
+ public:
+  static const ::Function& function(const ContextRequest* msg);
+};
+
+const ::Function&
+ContextRequest::_Internal::function(const ContextRequest* msg) {
+  return *msg->_impl_.function_;
+}
+ContextRequest::ContextRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:ContextRequest)
+}
+ContextRequest::ContextRequest(const ContextRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ContextRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.function_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_function()) {
+    _this->_impl_.function_ = new ::Function(*from._impl_.function_);
+  }
+  // @@protoc_insertion_point(copy_constructor:ContextRequest)
+}
+
+inline void ContextRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.function_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+ContextRequest::~ContextRequest() {
+  // @@protoc_insertion_point(destructor:ContextRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ContextRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.function_;
+}
+
+void ContextRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ContextRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:ContextRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && _impl_.function_ != nullptr) {
+    delete _impl_.function_;
+  }
+  _impl_.function_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ContextRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .Function function = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ContextRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:ContextRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .Function function = 1;
+  if (this->_internal_has_function()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::function(this),
+        _Internal::function(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:ContextRequest)
+  return target;
+}
+
+size_t ContextRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:ContextRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .Function function = 1;
+  if (this->_internal_has_function()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.function_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ContextRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextRequest::GetClassData() const { return &_class_data_; }
+
+
+void ContextRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ContextRequest*>(&to_msg);
+  auto& from = static_cast<const ContextRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:ContextRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_function()) {
+    _this->_internal_mutable_function()->::Function::MergeFrom(
+        from._internal_function());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ContextRequest::CopyFrom(const ContextRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:ContextRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContextRequest::IsInitialized() const {
+  return true;
+}
+
+void ContextRequest::InternalSwap(ContextRequest* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.function_, other->_impl_.function_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ContextRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[16]);
+}
+
+// ===================================================================
+
+class TestFeedback::_Internal {
+ public:
+};
+
+TestFeedback::TestFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:TestFeedback)
+}
+TestFeedback::TestFeedback(const TestFeedback& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TestFeedback* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.test_lattice_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.test_lattice_ = from._impl_.test_lattice_;
+  // @@protoc_insertion_point(copy_constructor:TestFeedback)
+}
+
+inline void TestFeedback::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.test_lattice_){0}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+TestFeedback::~TestFeedback() {
+  // @@protoc_insertion_point(destructor:TestFeedback)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TestFeedback::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void TestFeedback::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TestFeedback::Clear() {
+// @@protoc_insertion_point(message_clear_start:TestFeedback)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.test_lattice_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TestFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .TestLattice test_lattice = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_test_lattice(static_cast<::TestLattice>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TestFeedback::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:TestFeedback)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .TestLattice test_lattice = 1;
+  if (this->_internal_test_lattice() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_test_lattice(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:TestFeedback)
+  return target;
+}
+
+size_t TestFeedback::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:TestFeedback)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .TestLattice test_lattice = 1;
+  if (this->_internal_test_lattice() != 0) {
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_test_lattice());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TestFeedback::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TestFeedback::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TestFeedback::GetClassData() const { return &_class_data_; }
+
+
+void TestFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TestFeedback*>(&to_msg);
+  auto& from = static_cast<const TestFeedback&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:TestFeedback)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_test_lattice() != 0) {
+    _this->_internal_set_test_lattice(from._internal_test_lattice());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TestFeedback::CopyFrom(const TestFeedback& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:TestFeedback)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TestFeedback::IsInitialized() const {
+  return true;
+}
+
+void TestFeedback::InternalSwap(TestFeedback* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.test_lattice_, other->_impl_.test_lattice_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TestFeedback::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[17]);
+}
+
+// ===================================================================
+
+class CallFeedback::_Internal {
+ public:
+};
+
+CallFeedback::CallFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:CallFeedback)
+}
+CallFeedback::CallFeedback(const CallFeedback& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  CallFeedback* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.callee_hash_){}
+    , decltype(_impl_.n_calls_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.callee_hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.callee_hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_callee_hash().empty()) {
+    _this->_impl_.callee_hash_.Set(from._internal_callee_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.n_calls_ = from._impl_.n_calls_;
+  // @@protoc_insertion_point(copy_constructor:CallFeedback)
+}
+
+inline void CallFeedback::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.callee_hash_){}
+    , decltype(_impl_.n_calls_){int64_t{0}}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.callee_hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.callee_hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+CallFeedback::~CallFeedback() {
+  // @@protoc_insertion_point(destructor:CallFeedback)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void CallFeedback::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.callee_hash_.Destroy();
+}
+
+void CallFeedback::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void CallFeedback::Clear() {
+// @@protoc_insertion_point(message_clear_start:CallFeedback)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.callee_hash_.ClearToEmpty();
+  _impl_.n_calls_ = int64_t{0};
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CallFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int64 n_calls = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.n_calls_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes callee_hash = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_callee_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* CallFeedback::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:CallFeedback)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 n_calls = 1;
+  if (this->_internal_n_calls() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_n_calls(), target);
+  }
+
+  // bytes callee_hash = 2;
+  if (!this->_internal_callee_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_callee_hash(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:CallFeedback)
+  return target;
+}
+
+size_t CallFeedback::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:CallFeedback)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes callee_hash = 2;
+  if (!this->_internal_callee_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_callee_hash());
+  }
+
+  // int64 n_calls = 1;
+  if (this->_internal_n_calls() != 0) {
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_n_calls());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CallFeedback::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    CallFeedback::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CallFeedback::GetClassData() const { return &_class_data_; }
+
+
+void CallFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<CallFeedback*>(&to_msg);
+  auto& from = static_cast<const CallFeedback&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:CallFeedback)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_callee_hash().empty()) {
+    _this->_internal_set_callee_hash(from._internal_callee_hash());
+  }
+  if (from._internal_n_calls() != 0) {
+    _this->_internal_set_n_calls(from._internal_n_calls());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void CallFeedback::CopyFrom(const CallFeedback& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:CallFeedback)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CallFeedback::IsInitialized() const {
+  return true;
+}
+
+void CallFeedback::InternalSwap(CallFeedback* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.callee_hash_, lhs_arena,
+      &other->_impl_.callee_hash_, rhs_arena
+  );
+  swap(_impl_.n_calls_, other->_impl_.n_calls_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CallFeedback::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[18]);
+}
+
+// ===================================================================
+
+class ValueFeedback::_Internal {
+ public:
+};
+
+ValueFeedback::ValueFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:ValueFeedback)
+}
+ValueFeedback::ValueFeedback(const ValueFeedback& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  ValueFeedback* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.scalar_){}
+    , decltype(_impl_.object_){}
+    , decltype(_impl_.accessed_attributes_){}
+    , decltype(_impl_.vectorizable_){}
+    , decltype(_impl_.is_promise_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&_impl_.scalar_, &from._impl_.scalar_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_promise_) -
+    reinterpret_cast<char*>(&_impl_.scalar_)) + sizeof(_impl_.is_promise_));
+  // @@protoc_insertion_point(copy_constructor:ValueFeedback)
+}
+
+inline void ValueFeedback::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.scalar_){false}
+    , decltype(_impl_.object_){false}
+    , decltype(_impl_.accessed_attributes_){false}
+    , decltype(_impl_.vectorizable_){false}
+    , decltype(_impl_.is_promise_){false}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+ValueFeedback::~ValueFeedback() {
+  // @@protoc_insertion_point(destructor:ValueFeedback)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ValueFeedback::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ValueFeedback::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ValueFeedback::Clear() {
+// @@protoc_insertion_point(message_clear_start:ValueFeedback)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&_impl_.scalar_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.is_promise_) -
+      reinterpret_cast<char*>(&_impl_.scalar_)) + sizeof(_impl_.is_promise_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ValueFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bool scalar = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.scalar_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool object = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _impl_.object_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool accessed_attributes = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _impl_.accessed_attributes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool vectorizable = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _impl_.vectorizable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool is_promise = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _impl_.is_promise_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ValueFeedback::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:ValueFeedback)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bool scalar = 1;
+  if (this->_internal_scalar() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_scalar(), target);
+  }
+
+  // bool object = 2;
+  if (this->_internal_object() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_object(), target);
+  }
+
+  // bool accessed_attributes = 3;
+  if (this->_internal_accessed_attributes() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_accessed_attributes(), target);
+  }
+
+  // bool vectorizable = 4;
+  if (this->_internal_vectorizable() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_vectorizable(), target);
+  }
+
+  // bool is_promise = 5;
+  if (this->_internal_is_promise() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_is_promise(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:ValueFeedback)
+  return target;
+}
+
+size_t ValueFeedback::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:ValueFeedback)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bool scalar = 1;
+  if (this->_internal_scalar() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool object = 2;
+  if (this->_internal_object() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool accessed_attributes = 3;
+  if (this->_internal_accessed_attributes() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool vectorizable = 4;
+  if (this->_internal_vectorizable() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool is_promise = 5;
+  if (this->_internal_is_promise() != 0) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ValueFeedback::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    ValueFeedback::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ValueFeedback::GetClassData() const { return &_class_data_; }
+
+
+void ValueFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<ValueFeedback*>(&to_msg);
+  auto& from = static_cast<const ValueFeedback&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:ValueFeedback)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_scalar() != 0) {
+    _this->_internal_set_scalar(from._internal_scalar());
+  }
+  if (from._internal_object() != 0) {
+    _this->_internal_set_object(from._internal_object());
+  }
+  if (from._internal_accessed_attributes() != 0) {
+    _this->_internal_set_accessed_attributes(from._internal_accessed_attributes());
+  }
+  if (from._internal_vectorizable() != 0) {
+    _this->_internal_set_vectorizable(from._internal_vectorizable());
+  }
+  if (from._internal_is_promise() != 0) {
+    _this->_internal_set_is_promise(from._internal_is_promise());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ValueFeedback::CopyFrom(const ValueFeedback& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:ValueFeedback)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ValueFeedback::IsInitialized() const {
+  return true;
+}
+
+void ValueFeedback::InternalSwap(ValueFeedback* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ValueFeedback, _impl_.is_promise_)
+      + sizeof(ValueFeedback::_impl_.is_promise_)
+      - PROTOBUF_FIELD_OFFSET(ValueFeedback, _impl_.scalar_)>(
+          reinterpret_cast<char*>(&_impl_.scalar_),
+          reinterpret_cast<char*>(&other->_impl_.scalar_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ValueFeedback::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[19]);
+}
+
+// ===================================================================
+
+class TypeFeedback_Feedback::_Internal {
+ public:
+  static const ::TestFeedback& test_feedback(const TypeFeedback_Feedback* msg);
+  static const ::CallFeedback& call_feedback(const TypeFeedback_Feedback* msg);
+  static const ::ValueFeedback& value_feedback(const TypeFeedback_Feedback* msg);
+};
+
+const ::TestFeedback&
+TypeFeedback_Feedback::_Internal::test_feedback(const TypeFeedback_Feedback* msg) {
+  return *msg->_impl_.feedback_.test_feedback_;
+}
+const ::CallFeedback&
+TypeFeedback_Feedback::_Internal::call_feedback(const TypeFeedback_Feedback* msg) {
+  return *msg->_impl_.feedback_.call_feedback_;
+}
+const ::ValueFeedback&
+TypeFeedback_Feedback::_Internal::value_feedback(const TypeFeedback_Feedback* msg) {
+  return *msg->_impl_.feedback_.value_feedback_;
+}
+void TypeFeedback_Feedback::set_allocated_test_feedback(::TestFeedback* test_feedback) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_feedback();
+  if (test_feedback) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(test_feedback);
+    if (message_arena != submessage_arena) {
+      test_feedback = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, test_feedback, submessage_arena);
+    }
+    set_has_test_feedback();
+    _impl_.feedback_.test_feedback_ = test_feedback;
+  }
+  // @@protoc_insertion_point(field_set_allocated:TypeFeedback.Feedback.test_feedback)
+}
+void TypeFeedback_Feedback::set_allocated_call_feedback(::CallFeedback* call_feedback) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_feedback();
+  if (call_feedback) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(call_feedback);
+    if (message_arena != submessage_arena) {
+      call_feedback = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, call_feedback, submessage_arena);
+    }
+    set_has_call_feedback();
+    _impl_.feedback_.call_feedback_ = call_feedback;
+  }
+  // @@protoc_insertion_point(field_set_allocated:TypeFeedback.Feedback.call_feedback)
+}
+void TypeFeedback_Feedback::set_allocated_value_feedback(::ValueFeedback* value_feedback) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_feedback();
+  if (value_feedback) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value_feedback);
+    if (message_arena != submessage_arena) {
+      value_feedback = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value_feedback, submessage_arena);
+    }
+    set_has_value_feedback();
+    _impl_.feedback_.value_feedback_ = value_feedback;
+  }
+  // @@protoc_insertion_point(field_set_allocated:TypeFeedback.Feedback.value_feedback)
+}
+TypeFeedback_Feedback::TypeFeedback_Feedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:TypeFeedback.Feedback)
+}
+TypeFeedback_Feedback::TypeFeedback_Feedback(const TypeFeedback_Feedback& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TypeFeedback_Feedback* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.feedback_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_feedback();
+  switch (from.feedback_case()) {
+    case kTestFeedback: {
+      _this->_internal_mutable_test_feedback()->::TestFeedback::MergeFrom(
+          from._internal_test_feedback());
+      break;
+    }
+    case kCallFeedback: {
+      _this->_internal_mutable_call_feedback()->::CallFeedback::MergeFrom(
+          from._internal_call_feedback());
+      break;
+    }
+    case kValueFeedback: {
+      _this->_internal_mutable_value_feedback()->::ValueFeedback::MergeFrom(
+          from._internal_value_feedback());
+      break;
+    }
+    case FEEDBACK_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:TypeFeedback.Feedback)
+}
+
+inline void TypeFeedback_Feedback::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.feedback_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_feedback();
+}
+
+TypeFeedback_Feedback::~TypeFeedback_Feedback() {
+  // @@protoc_insertion_point(destructor:TypeFeedback.Feedback)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TypeFeedback_Feedback::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_feedback()) {
+    clear_feedback();
+  }
+}
+
+void TypeFeedback_Feedback::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TypeFeedback_Feedback::clear_feedback() {
+// @@protoc_insertion_point(one_of_clear_start:TypeFeedback.Feedback)
+  switch (feedback_case()) {
+    case kTestFeedback: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.feedback_.test_feedback_;
+      }
+      break;
+    }
+    case kCallFeedback: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.feedback_.call_feedback_;
+      }
+      break;
+    }
+    case kValueFeedback: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete _impl_.feedback_.value_feedback_;
+      }
+      break;
+    }
+    case FEEDBACK_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = FEEDBACK_NOT_SET;
+}
+
+
+void TypeFeedback_Feedback::Clear() {
+// @@protoc_insertion_point(message_clear_start:TypeFeedback.Feedback)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_feedback();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TypeFeedback_Feedback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .TestFeedback test_feedback = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_test_feedback(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .CallFeedback call_feedback = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_call_feedback(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .ValueFeedback value_feedback = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value_feedback(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TypeFeedback_Feedback::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:TypeFeedback.Feedback)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .TestFeedback test_feedback = 1;
+  if (_internal_has_test_feedback()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::test_feedback(this),
+        _Internal::test_feedback(this).GetCachedSize(), target, stream);
+  }
+
+  // .CallFeedback call_feedback = 2;
+  if (_internal_has_call_feedback()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::call_feedback(this),
+        _Internal::call_feedback(this).GetCachedSize(), target, stream);
+  }
+
+  // .ValueFeedback value_feedback = 3;
+  if (_internal_has_value_feedback()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::value_feedback(this),
+        _Internal::value_feedback(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:TypeFeedback.Feedback)
+  return target;
+}
+
+size_t TypeFeedback_Feedback::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:TypeFeedback.Feedback)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (feedback_case()) {
+    // .TestFeedback test_feedback = 1;
+    case kTestFeedback: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.feedback_.test_feedback_);
+      break;
+    }
+    // .CallFeedback call_feedback = 2;
+    case kCallFeedback: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.feedback_.call_feedback_);
+      break;
+    }
+    // .ValueFeedback value_feedback = 3;
+    case kValueFeedback: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.feedback_.value_feedback_);
+      break;
+    }
+    case FEEDBACK_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TypeFeedback_Feedback::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TypeFeedback_Feedback::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TypeFeedback_Feedback::GetClassData() const { return &_class_data_; }
+
+
+void TypeFeedback_Feedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TypeFeedback_Feedback*>(&to_msg);
+  auto& from = static_cast<const TypeFeedback_Feedback&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:TypeFeedback.Feedback)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.feedback_case()) {
+    case kTestFeedback: {
+      _this->_internal_mutable_test_feedback()->::TestFeedback::MergeFrom(
+          from._internal_test_feedback());
+      break;
+    }
+    case kCallFeedback: {
+      _this->_internal_mutable_call_feedback()->::CallFeedback::MergeFrom(
+          from._internal_call_feedback());
+      break;
+    }
+    case kValueFeedback: {
+      _this->_internal_mutable_value_feedback()->::ValueFeedback::MergeFrom(
+          from._internal_value_feedback());
+      break;
+    }
+    case FEEDBACK_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TypeFeedback_Feedback::CopyFrom(const TypeFeedback_Feedback& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:TypeFeedback.Feedback)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TypeFeedback_Feedback::IsInitialized() const {
+  return true;
+}
+
+void TypeFeedback_Feedback::InternalSwap(TypeFeedback_Feedback* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.feedback_, other->_impl_.feedback_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TypeFeedback_Feedback::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[20]);
+}
+
+// ===================================================================
+
+TypeFeedback_TypesEntry_DoNotUse::TypeFeedback_TypesEntry_DoNotUse() {}
+TypeFeedback_TypesEntry_DoNotUse::TypeFeedback_TypesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+    : SuperType(arena) {}
+void TypeFeedback_TypesEntry_DoNotUse::MergeFrom(const TypeFeedback_TypesEntry_DoNotUse& other) {
+  MergeFromInternal(other);
+}
+::PROTOBUF_NAMESPACE_ID::Metadata TypeFeedback_TypesEntry_DoNotUse::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[21]);
+}
+
+// ===================================================================
+
+class TypeFeedback::_Internal {
+ public:
+};
+
+TypeFeedback::TypeFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  if (arena != nullptr && !is_message_owned) {
+    arena->OwnCustomDestructor(this, &TypeFeedback::ArenaDtor);
+  }
+  // @@protoc_insertion_point(arena_constructor:TypeFeedback)
+}
+TypeFeedback::TypeFeedback(const TypeFeedback& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  TypeFeedback* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      /*decltype(_impl_.types_)*/{}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _this->_impl_.types_.MergeFrom(from._impl_.types_);
+  // @@protoc_insertion_point(copy_constructor:TypeFeedback)
+}
+
+inline void TypeFeedback::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      /*decltype(_impl_.types_)*/{::_pbi::ArenaInitialized(), arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+TypeFeedback::~TypeFeedback() {
+  // @@protoc_insertion_point(destructor:TypeFeedback)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    ArenaDtor(this);
+    return;
+  }
+  SharedDtor();
+}
+
+inline void TypeFeedback::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.types_.Destruct();
+  _impl_.types_.~MapField();
+}
+
+void TypeFeedback::ArenaDtor(void* object) {
+  TypeFeedback* _this = reinterpret_cast< TypeFeedback* >(object);
+  _this->_impl_.types_.Destruct();
+}
+void TypeFeedback::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void TypeFeedback::Clear() {
+// @@protoc_insertion_point(message_clear_start:TypeFeedback)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.types_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* TypeFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // map<int64, .TypeFeedback.Feedback> types = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(&_impl_.types_, ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* TypeFeedback::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:TypeFeedback)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // map<int64, .TypeFeedback.Feedback> types = 2;
+  if (!this->_internal_types().empty()) {
+    using MapType = ::_pb::Map<int64_t, ::TypeFeedback_Feedback>;
+    using WireHelper = TypeFeedback_TypesEntry_DoNotUse::Funcs;
+    const auto& map_field = this->_internal_types();
+
+    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
+      for (const auto& entry : ::_pbi::MapSorterFlat<MapType>(map_field)) {
+        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
+      }
+    } else {
+      for (const auto& entry : map_field) {
+        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
+      }
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:TypeFeedback)
+  return target;
+}
+
+size_t TypeFeedback::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:TypeFeedback)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // map<int64, .TypeFeedback.Feedback> types = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_types_size());
+  for (::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >::const_iterator
+      it = this->_internal_types().begin();
+      it != this->_internal_types().end(); ++it) {
+    total_size += TypeFeedback_TypesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TypeFeedback::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    TypeFeedback::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TypeFeedback::GetClassData() const { return &_class_data_; }
+
+
+void TypeFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<TypeFeedback*>(&to_msg);
+  auto& from = static_cast<const TypeFeedback&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:TypeFeedback)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.types_.MergeFrom(from._impl_.types_);
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void TypeFeedback::CopyFrom(const TypeFeedback& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:TypeFeedback)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TypeFeedback::IsInitialized() const {
+  return true;
+}
+
+void TypeFeedback::InternalSwap(TypeFeedback* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.types_.InternalSwap(&other->_impl_.types_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TypeFeedback::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[22]);
+}
+
+// ===================================================================
+
+class FeedbackRequest::_Internal {
+ public:
+  static const ::Function& function(const FeedbackRequest* msg);
+};
+
+const ::Function&
+FeedbackRequest::_Internal::function(const FeedbackRequest* msg) {
+  return *msg->_impl_.function_;
+}
+FeedbackRequest::FeedbackRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:FeedbackRequest)
+}
+FeedbackRequest::FeedbackRequest(const FeedbackRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  FeedbackRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.function_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_function()) {
+    _this->_impl_.function_ = new ::Function(*from._impl_.function_);
+  }
+  // @@protoc_insertion_point(copy_constructor:FeedbackRequest)
+}
+
+inline void FeedbackRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.function_){nullptr}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+FeedbackRequest::~FeedbackRequest() {
+  // @@protoc_insertion_point(destructor:FeedbackRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void FeedbackRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.function_;
+}
+
+void FeedbackRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void FeedbackRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:FeedbackRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && _impl_.function_ != nullptr) {
+    delete _impl_.function_;
+  }
+  _impl_.function_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FeedbackRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .Function function = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FeedbackRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:FeedbackRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .Function function = 1;
+  if (this->_internal_has_function()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::function(this),
+        _Internal::function(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:FeedbackRequest)
+  return target;
+}
+
+size_t FeedbackRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:FeedbackRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .Function function = 1;
+  if (this->_internal_has_function()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.function_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FeedbackRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    FeedbackRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FeedbackRequest::GetClassData() const { return &_class_data_; }
+
+
+void FeedbackRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<FeedbackRequest*>(&to_msg);
+  auto& from = static_cast<const FeedbackRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:FeedbackRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_function()) {
+    _this->_internal_mutable_function()->::Function::MergeFrom(
+        from._internal_function());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FeedbackRequest::CopyFrom(const FeedbackRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:FeedbackRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FeedbackRequest::IsInitialized() const {
+  return true;
+}
+
+void FeedbackRequest::InternalSwap(FeedbackRequest* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.function_, other->_impl_.function_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FeedbackRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[23]);
+}
+
+// ===================================================================
+
+class PackageSource::_Internal {
+ public:
+};
+
+PackageSource::PackageSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:PackageSource)
+}
+PackageSource::PackageSource(const PackageSource& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PackageSource* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.source_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_source();
+  switch (from.source_case()) {
+    case kRMirror: {
+      _this->_internal_set_r_mirror(from._internal_r_mirror());
+      break;
+    }
+    case kGithubUrl: {
+      _this->_internal_set_github_url(from._internal_github_url());
+      break;
+    }
+    case SOURCE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:PackageSource)
+}
+
+inline void PackageSource::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.source_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , /*decltype(_impl_._oneof_case_)*/{}
+  };
+  clear_has_source();
+}
+
+PackageSource::~PackageSource() {
+  // @@protoc_insertion_point(destructor:PackageSource)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PackageSource::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_source()) {
+    clear_source();
+  }
+}
+
+void PackageSource::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PackageSource::clear_source() {
+// @@protoc_insertion_point(one_of_clear_start:PackageSource)
+  switch (source_case()) {
+    case kRMirror: {
+      _impl_.source_.r_mirror_.Destroy();
+      break;
+    }
+    case kGithubUrl: {
+      _impl_.source_.github_url_.Destroy();
+      break;
+    }
+    case SOURCE_NOT_SET: {
+      break;
+    }
+  }
+  _impl_._oneof_case_[0] = SOURCE_NOT_SET;
+}
+
+
+void PackageSource::Clear() {
+// @@protoc_insertion_point(message_clear_start:PackageSource)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_source();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PackageSource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string r_mirror = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_r_mirror();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          CHK_(::_pbi::VerifyUTF8(str, "PackageSource.r_mirror"));
+        } else
+          goto handle_unusual;
+        continue;
+      // string github_url = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_github_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          CHK_(::_pbi::VerifyUTF8(str, "PackageSource.github_url"));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PackageSource::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:PackageSource)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string r_mirror = 2;
+  if (_internal_has_r_mirror()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_r_mirror().data(), static_cast<int>(this->_internal_r_mirror().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "PackageSource.r_mirror");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_r_mirror(), target);
+  }
+
+  // string github_url = 3;
+  if (_internal_has_github_url()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_github_url().data(), static_cast<int>(this->_internal_github_url().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "PackageSource.github_url");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_github_url(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:PackageSource)
+  return target;
+}
+
+size_t PackageSource::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:PackageSource)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (source_case()) {
+    // string r_mirror = 2;
+    case kRMirror: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_r_mirror());
+      break;
+    }
+    // string github_url = 3;
+    case kGithubUrl: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_github_url());
+      break;
+    }
+    case SOURCE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PackageSource::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PackageSource::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PackageSource::GetClassData() const { return &_class_data_; }
+
+
+void PackageSource::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PackageSource*>(&to_msg);
+  auto& from = static_cast<const PackageSource&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:PackageSource)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.source_case()) {
+    case kRMirror: {
+      _this->_internal_set_r_mirror(from._internal_r_mirror());
+      break;
+    }
+    case kGithubUrl: {
+      _this->_internal_set_github_url(from._internal_github_url());
+      break;
+    }
+    case SOURCE_NOT_SET: {
+      break;
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PackageSource::CopyFrom(const PackageSource& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:PackageSource)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PackageSource::IsInitialized() const {
+  return true;
+}
+
+void PackageSource::InternalSwap(PackageSource* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_.source_, other->_impl_.source_);
+  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PackageSource::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[24]);
+}
+
+// ===================================================================
+
+class Package::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Package>()._impl_._has_bits_);
+  static const ::Version& version(const Package* msg);
+  static const ::PackageSource& source(const Package* msg);
+  static void set_has_source(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::Version&
+Package::_Internal::version(const Package* msg) {
+  return *msg->_impl_.version_;
+}
+const ::PackageSource&
+Package::_Internal::source(const Package* msg) {
+  return *msg->_impl_.source_;
+}
+Package::Package(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:Package)
+}
+Package::Package(const Package& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  Package* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.function_hashes_){from._impl_.function_hashes_}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.source_){nullptr}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    _this->_impl_.name_.Set(from._internal_name(), 
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_version()) {
+    _this->_impl_.version_ = new ::Version(*from._impl_.version_);
+  }
+  if (from._internal_has_source()) {
+    _this->_impl_.source_ = new ::PackageSource(*from._impl_.source_);
+  }
+  // @@protoc_insertion_point(copy_constructor:Package)
+}
+
+inline void Package::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.function_hashes_){arena}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.version_){nullptr}
+    , decltype(_impl_.source_){nullptr}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Package::~Package() {
+  // @@protoc_insertion_point(destructor:Package)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void Package::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.function_hashes_.~RepeatedPtrField();
+  _impl_.name_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.version_;
+  if (this != internal_default_instance()) delete _impl_.source_;
+}
+
+void Package::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void Package::Clear() {
+// @@protoc_insertion_point(message_clear_start:Package)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.function_hashes_.Clear();
+  _impl_.name_.ClearToEmpty();
+  if (GetArenaForAllocation() == nullptr && _impl_.version_ != nullptr) {
+    delete _impl_.version_;
+  }
+  _impl_.version_ = nullptr;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.source_ != nullptr);
+    _impl_.source_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Package::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+          CHK_(::_pbi::VerifyUTF8(str, "Package.name"));
+        } else
+          goto handle_unusual;
+        continue;
+      // .Version version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_version(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated bytes function_hashes = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_function_hashes();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .PackageSource source = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_source(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Package::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:Package)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "Package.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // .Version version = 2;
+  if (this->_internal_has_version()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::version(this),
+        _Internal::version(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated bytes function_hashes = 4;
+  for (int i = 0, n = this->_internal_function_hashes_size(); i < n; i++) {
+    const auto& s = this->_internal_function_hashes(i);
+    target = stream->WriteBytes(4, s, target);
+  }
+
+  // optional .PackageSource source = 5;
+  if (_internal_has_source()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::source(this),
+        _Internal::source(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:Package)
+  return target;
+}
+
+size_t Package::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:Package)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated bytes function_hashes = 4;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.function_hashes_.size());
+  for (int i = 0, n = _impl_.function_hashes_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      _impl_.function_hashes_.Get(i));
+  }
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // .Version version = 2;
+  if (this->_internal_has_version()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.version_);
+  }
+
+  // optional .PackageSource source = 5;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.source_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Package::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    Package::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Package::GetClassData() const { return &_class_data_; }
+
+
+void Package::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<Package*>(&to_msg);
+  auto& from = static_cast<const Package&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:Package)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.function_hashes_.MergeFrom(from._impl_.function_hashes_);
+  if (!from._internal_name().empty()) {
+    _this->_internal_set_name(from._internal_name());
+  }
+  if (from._internal_has_version()) {
+    _this->_internal_mutable_version()->::Version::MergeFrom(
+        from._internal_version());
+  }
+  if (from._internal_has_source()) {
+    _this->_internal_mutable_source()->::PackageSource::MergeFrom(
+        from._internal_source());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Package::CopyFrom(const Package& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:Package)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Package::IsInitialized() const {
+  return true;
+}
+
+void Package::InternalSwap(Package* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.function_hashes_.InternalSwap(&other->_impl_.function_hashes_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Package, _impl_.source_)
+      + sizeof(Package::_impl_.source_)
+      - PROTOBUF_FIELD_OFFSET(Package, _impl_.version_)>(
+          reinterpret_cast<char*>(&_impl_.version_),
+          reinterpret_cast<char*>(&other->_impl_.version_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Package::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[25]);
+}
+
+// ===================================================================
+
+class PackageRequest::_Internal {
+ public:
+};
+
+PackageRequest::PackageRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:PackageRequest)
+}
+PackageRequest::PackageRequest(const PackageRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  PackageRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_hash().empty()) {
+    _this->_impl_.hash_.Set(from._internal_hash(), 
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:PackageRequest)
+}
+
+inline void PackageRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.hash_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+  _impl_.hash_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+PackageRequest::~PackageRequest() {
+  // @@protoc_insertion_point(destructor:PackageRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void PackageRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.hash_.Destroy();
+}
+
+void PackageRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void PackageRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:PackageRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.hash_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PackageRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes hash = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_hash();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PackageRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:PackageRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_hash(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:PackageRequest)
+  return target;
+}
+
+size_t PackageRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:PackageRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes hash = 1;
+  if (!this->_internal_hash().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_hash());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PackageRequest::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+    PackageRequest::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PackageRequest::GetClassData() const { return &_class_data_; }
+
+
+void PackageRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
+  auto* const _this = static_cast<PackageRequest*>(&to_msg);
+  auto& from = static_cast<const PackageRequest&>(from_msg);
+  // @@protoc_insertion_point(class_specific_merge_from_start:PackageRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_hash().empty()) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
+  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PackageRequest::CopyFrom(const PackageRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:PackageRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PackageRequest::IsInitialized() const {
+  return true;
+}
+
+void PackageRequest::InternalSwap(PackageRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.hash_, lhs_arena,
+      &other->_impl_.hash_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PackageRequest::GetMetadata() const {
+  return ::_pbi::AssignDescriptors(
+      &descriptor_table_messages_2eproto_getter, &descriptor_table_messages_2eproto_once,
+      file_level_metadata_messages_2eproto[26]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::Version*
+Arena::CreateMaybeMessage< ::Version >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Version >(arena);
+}
+template<> PROTOBUF_NOINLINE ::InitRequest*
+Arena::CreateMaybeMessage< ::InitRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::InitRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::InitResponse*
+Arena::CreateMaybeMessage< ::InitResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::InitResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::CompileRequest*
+Arena::CreateMaybeMessage< ::CompileRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CompileRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::CompileResponse*
+Arena::CreateMaybeMessage< ::CompileResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CompileResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Function*
+Arena::CreateMaybeMessage< ::Function >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Function >(arena);
+}
+template<> PROTOBUF_NOINLINE ::FunctionRequest*
+Arena::CreateMaybeMessage< ::FunctionRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::FunctionRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Environment_ValuesEntry_DoNotUse*
+Arena::CreateMaybeMessage< ::Environment_ValuesEntry_DoNotUse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Environment_ValuesEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Environment*
+Arena::CreateMaybeMessage< ::Environment >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Environment >(arena);
+}
+template<> PROTOBUF_NOINLINE ::ValueRequest*
+Arena::CreateMaybeMessage< ::ValueRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::ValueRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Value*
+Arena::CreateMaybeMessage< ::Value >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Value >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Values*
+Arena::CreateMaybeMessage< ::Values >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Values >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Empty*
+Arena::CreateMaybeMessage< ::Empty >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Empty >(arena);
+}
+template<> PROTOBUF_NOINLINE ::CallContext*
+Arena::CreateMaybeMessage< ::CallContext >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CallContext >(arena);
+}
+template<> PROTOBUF_NOINLINE ::ArgumentContext*
+Arena::CreateMaybeMessage< ::ArgumentContext >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::ArgumentContext >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Context*
+Arena::CreateMaybeMessage< ::Context >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Context >(arena);
+}
+template<> PROTOBUF_NOINLINE ::ContextRequest*
+Arena::CreateMaybeMessage< ::ContextRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::ContextRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::TestFeedback*
+Arena::CreateMaybeMessage< ::TestFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::TestFeedback >(arena);
+}
+template<> PROTOBUF_NOINLINE ::CallFeedback*
+Arena::CreateMaybeMessage< ::CallFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::CallFeedback >(arena);
+}
+template<> PROTOBUF_NOINLINE ::ValueFeedback*
+Arena::CreateMaybeMessage< ::ValueFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::ValueFeedback >(arena);
+}
+template<> PROTOBUF_NOINLINE ::TypeFeedback_Feedback*
+Arena::CreateMaybeMessage< ::TypeFeedback_Feedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::TypeFeedback_Feedback >(arena);
+}
+template<> PROTOBUF_NOINLINE ::TypeFeedback_TypesEntry_DoNotUse*
+Arena::CreateMaybeMessage< ::TypeFeedback_TypesEntry_DoNotUse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::TypeFeedback_TypesEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::TypeFeedback*
+Arena::CreateMaybeMessage< ::TypeFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::TypeFeedback >(arena);
+}
+template<> PROTOBUF_NOINLINE ::FeedbackRequest*
+Arena::CreateMaybeMessage< ::FeedbackRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::FeedbackRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::PackageSource*
+Arena::CreateMaybeMessage< ::PackageSource >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::PackageSource >(arena);
+}
+template<> PROTOBUF_NOINLINE ::Package*
+Arena::CreateMaybeMessage< ::Package >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Package >(arena);
+}
+template<> PROTOBUF_NOINLINE ::PackageRequest*
+Arena::CreateMaybeMessage< ::PackageRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::PackageRequest >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/client/rsh/src/messages.pb.h b/client/rsh/src/messages.pb.h
new file mode 100644
index 000000000..b28d96991
--- /dev/null
+++ b/client/rsh/src/messages.pb.h
@@ -0,0 +1,7721 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: messages.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_messages_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_messages_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_bases.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_messages_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_messages_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2eproto;
+class ArgumentContext;
+struct ArgumentContextDefaultTypeInternal;
+extern ArgumentContextDefaultTypeInternal _ArgumentContext_default_instance_;
+class CallContext;
+struct CallContextDefaultTypeInternal;
+extern CallContextDefaultTypeInternal _CallContext_default_instance_;
+class CallFeedback;
+struct CallFeedbackDefaultTypeInternal;
+extern CallFeedbackDefaultTypeInternal _CallFeedback_default_instance_;
+class CompileRequest;
+struct CompileRequestDefaultTypeInternal;
+extern CompileRequestDefaultTypeInternal _CompileRequest_default_instance_;
+class CompileResponse;
+struct CompileResponseDefaultTypeInternal;
+extern CompileResponseDefaultTypeInternal _CompileResponse_default_instance_;
+class Context;
+struct ContextDefaultTypeInternal;
+extern ContextDefaultTypeInternal _Context_default_instance_;
+class ContextRequest;
+struct ContextRequestDefaultTypeInternal;
+extern ContextRequestDefaultTypeInternal _ContextRequest_default_instance_;
+class Empty;
+struct EmptyDefaultTypeInternal;
+extern EmptyDefaultTypeInternal _Empty_default_instance_;
+class Environment;
+struct EnvironmentDefaultTypeInternal;
+extern EnvironmentDefaultTypeInternal _Environment_default_instance_;
+class Environment_ValuesEntry_DoNotUse;
+struct Environment_ValuesEntry_DoNotUseDefaultTypeInternal;
+extern Environment_ValuesEntry_DoNotUseDefaultTypeInternal _Environment_ValuesEntry_DoNotUse_default_instance_;
+class FeedbackRequest;
+struct FeedbackRequestDefaultTypeInternal;
+extern FeedbackRequestDefaultTypeInternal _FeedbackRequest_default_instance_;
+class Function;
+struct FunctionDefaultTypeInternal;
+extern FunctionDefaultTypeInternal _Function_default_instance_;
+class FunctionRequest;
+struct FunctionRequestDefaultTypeInternal;
+extern FunctionRequestDefaultTypeInternal _FunctionRequest_default_instance_;
+class InitRequest;
+struct InitRequestDefaultTypeInternal;
+extern InitRequestDefaultTypeInternal _InitRequest_default_instance_;
+class InitResponse;
+struct InitResponseDefaultTypeInternal;
+extern InitResponseDefaultTypeInternal _InitResponse_default_instance_;
+class Package;
+struct PackageDefaultTypeInternal;
+extern PackageDefaultTypeInternal _Package_default_instance_;
+class PackageRequest;
+struct PackageRequestDefaultTypeInternal;
+extern PackageRequestDefaultTypeInternal _PackageRequest_default_instance_;
+class PackageSource;
+struct PackageSourceDefaultTypeInternal;
+extern PackageSourceDefaultTypeInternal _PackageSource_default_instance_;
+class TestFeedback;
+struct TestFeedbackDefaultTypeInternal;
+extern TestFeedbackDefaultTypeInternal _TestFeedback_default_instance_;
+class TypeFeedback;
+struct TypeFeedbackDefaultTypeInternal;
+extern TypeFeedbackDefaultTypeInternal _TypeFeedback_default_instance_;
+class TypeFeedback_Feedback;
+struct TypeFeedback_FeedbackDefaultTypeInternal;
+extern TypeFeedback_FeedbackDefaultTypeInternal _TypeFeedback_Feedback_default_instance_;
+class TypeFeedback_TypesEntry_DoNotUse;
+struct TypeFeedback_TypesEntry_DoNotUseDefaultTypeInternal;
+extern TypeFeedback_TypesEntry_DoNotUseDefaultTypeInternal _TypeFeedback_TypesEntry_DoNotUse_default_instance_;
+class Value;
+struct ValueDefaultTypeInternal;
+extern ValueDefaultTypeInternal _Value_default_instance_;
+class ValueFeedback;
+struct ValueFeedbackDefaultTypeInternal;
+extern ValueFeedbackDefaultTypeInternal _ValueFeedback_default_instance_;
+class ValueRequest;
+struct ValueRequestDefaultTypeInternal;
+extern ValueRequestDefaultTypeInternal _ValueRequest_default_instance_;
+class Values;
+struct ValuesDefaultTypeInternal;
+extern ValuesDefaultTypeInternal _Values_default_instance_;
+class Version;
+struct VersionDefaultTypeInternal;
+extern VersionDefaultTypeInternal _Version_default_instance_;
+PROTOBUF_NAMESPACE_OPEN
+template<> ::ArgumentContext* Arena::CreateMaybeMessage<::ArgumentContext>(Arena*);
+template<> ::CallContext* Arena::CreateMaybeMessage<::CallContext>(Arena*);
+template<> ::CallFeedback* Arena::CreateMaybeMessage<::CallFeedback>(Arena*);
+template<> ::CompileRequest* Arena::CreateMaybeMessage<::CompileRequest>(Arena*);
+template<> ::CompileResponse* Arena::CreateMaybeMessage<::CompileResponse>(Arena*);
+template<> ::Context* Arena::CreateMaybeMessage<::Context>(Arena*);
+template<> ::ContextRequest* Arena::CreateMaybeMessage<::ContextRequest>(Arena*);
+template<> ::Empty* Arena::CreateMaybeMessage<::Empty>(Arena*);
+template<> ::Environment* Arena::CreateMaybeMessage<::Environment>(Arena*);
+template<> ::Environment_ValuesEntry_DoNotUse* Arena::CreateMaybeMessage<::Environment_ValuesEntry_DoNotUse>(Arena*);
+template<> ::FeedbackRequest* Arena::CreateMaybeMessage<::FeedbackRequest>(Arena*);
+template<> ::Function* Arena::CreateMaybeMessage<::Function>(Arena*);
+template<> ::FunctionRequest* Arena::CreateMaybeMessage<::FunctionRequest>(Arena*);
+template<> ::InitRequest* Arena::CreateMaybeMessage<::InitRequest>(Arena*);
+template<> ::InitResponse* Arena::CreateMaybeMessage<::InitResponse>(Arena*);
+template<> ::Package* Arena::CreateMaybeMessage<::Package>(Arena*);
+template<> ::PackageRequest* Arena::CreateMaybeMessage<::PackageRequest>(Arena*);
+template<> ::PackageSource* Arena::CreateMaybeMessage<::PackageSource>(Arena*);
+template<> ::TestFeedback* Arena::CreateMaybeMessage<::TestFeedback>(Arena*);
+template<> ::TypeFeedback* Arena::CreateMaybeMessage<::TypeFeedback>(Arena*);
+template<> ::TypeFeedback_Feedback* Arena::CreateMaybeMessage<::TypeFeedback_Feedback>(Arena*);
+template<> ::TypeFeedback_TypesEntry_DoNotUse* Arena::CreateMaybeMessage<::TypeFeedback_TypesEntry_DoNotUse>(Arena*);
+template<> ::Value* Arena::CreateMaybeMessage<::Value>(Arena*);
+template<> ::ValueFeedback* Arena::CreateMaybeMessage<::ValueFeedback>(Arena*);
+template<> ::ValueRequest* Arena::CreateMaybeMessage<::ValueRequest>(Arena*);
+template<> ::Values* Arena::CreateMaybeMessage<::Values>(Arena*);
+template<> ::Version* Arena::CreateMaybeMessage<::Version>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+
+enum Tier : int {
+  BASELINE = 0,
+  OPTIMIZED = 1,
+  Tier_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  Tier_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool Tier_IsValid(int value);
+constexpr Tier Tier_MIN = BASELINE;
+constexpr Tier Tier_MAX = OPTIMIZED;
+constexpr int Tier_ARRAYSIZE = Tier_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Tier_descriptor();
+template<typename T>
+inline const std::string& Tier_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Tier>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Tier_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Tier_descriptor(), enum_t_value);
+}
+inline bool Tier_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Tier* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Tier>(
+    Tier_descriptor(), name, value);
+}
+enum TestLattice : int {
+  BOTH = 0,
+  ONLY_TRUE = 1,
+  ONLY_FALSE = 2,
+  NONE = 3,
+  TestLattice_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  TestLattice_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool TestLattice_IsValid(int value);
+constexpr TestLattice TestLattice_MIN = BOTH;
+constexpr TestLattice TestLattice_MAX = NONE;
+constexpr int TestLattice_ARRAYSIZE = TestLattice_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TestLattice_descriptor();
+template<typename T>
+inline const std::string& TestLattice_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, TestLattice>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function TestLattice_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    TestLattice_descriptor(), enum_t_value);
+}
+inline bool TestLattice_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TestLattice* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TestLattice>(
+    TestLattice_descriptor(), name, value);
+}
+enum Type : int {
+  ANY = 0,
+  INTEGER = 1,
+  REAL = 2,
+  Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool Type_IsValid(int value);
+constexpr Type Type_MIN = ANY;
+constexpr Type Type_MAX = REAL;
+constexpr int Type_ARRAYSIZE = Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_descriptor();
+template<typename T>
+inline const std::string& Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Type_descriptor(), enum_t_value);
+}
+inline bool Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Type>(
+    Type_descriptor(), name, value);
+}
+// ===================================================================
+
+class Version final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Version) */ {
+ public:
+  inline Version() : Version(nullptr) {}
+  ~Version() override;
+  explicit PROTOBUF_CONSTEXPR Version(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Version(const Version& from);
+  Version(Version&& from) noexcept
+    : Version() {
+    *this = ::std::move(from);
+  }
+
+  inline Version& operator=(const Version& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Version& operator=(Version&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Version& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Version* internal_default_instance() {
+    return reinterpret_cast<const Version*>(
+               &_Version_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Version& a, Version& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Version* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Version* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Version* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Version>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Version& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Version& from) {
+    Version::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Version* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Version";
+  }
+  protected:
+  explicit Version(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMajorFieldNumber = 1,
+    kMinorFieldNumber = 2,
+    kPatchFieldNumber = 3,
+  };
+  // int32 major = 1;
+  void clear_major();
+  int32_t major() const;
+  void set_major(int32_t value);
+  private:
+  int32_t _internal_major() const;
+  void _internal_set_major(int32_t value);
+  public:
+
+  // int32 minor = 2;
+  void clear_minor();
+  int32_t minor() const;
+  void set_minor(int32_t value);
+  private:
+  int32_t _internal_minor() const;
+  void _internal_set_minor(int32_t value);
+  public:
+
+  // int32 patch = 3;
+  void clear_patch();
+  int32_t patch() const;
+  void set_patch(int32_t value);
+  private:
+  int32_t _internal_patch() const;
+  void _internal_set_patch(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:Version)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t major_;
+    int32_t minor_;
+    int32_t patch_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class InitRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:InitRequest) */ {
+ public:
+  inline InitRequest() : InitRequest(nullptr) {}
+  ~InitRequest() override;
+  explicit PROTOBUF_CONSTEXPR InitRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  InitRequest(const InitRequest& from);
+  InitRequest(InitRequest&& from) noexcept
+    : InitRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline InitRequest& operator=(const InitRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline InitRequest& operator=(InitRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const InitRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const InitRequest* internal_default_instance() {
+    return reinterpret_cast<const InitRequest*>(
+               &_InitRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(InitRequest& a, InitRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(InitRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(InitRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  InitRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<InitRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const InitRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const InitRequest& from) {
+    InitRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(InitRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "InitRequest";
+  }
+  protected:
+  explicit InitRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPackageHashFieldNumber = 4,
+    kPlatformFieldNumber = 3,
+    kRshVersionFieldNumber = 1,
+    kRVersionFieldNumber = 2,
+  };
+  // repeated bytes package_hash = 4;
+  int package_hash_size() const;
+  private:
+  int _internal_package_hash_size() const;
+  public:
+  void clear_package_hash();
+  const std::string& package_hash(int index) const;
+  std::string* mutable_package_hash(int index);
+  void set_package_hash(int index, const std::string& value);
+  void set_package_hash(int index, std::string&& value);
+  void set_package_hash(int index, const char* value);
+  void set_package_hash(int index, const void* value, size_t size);
+  std::string* add_package_hash();
+  void add_package_hash(const std::string& value);
+  void add_package_hash(std::string&& value);
+  void add_package_hash(const char* value);
+  void add_package_hash(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& package_hash() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_package_hash();
+  private:
+  const std::string& _internal_package_hash(int index) const;
+  std::string* _internal_add_package_hash();
+  public:
+
+  // string platform = 3;
+  void clear_platform();
+  const std::string& platform() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_platform();
+  PROTOBUF_NODISCARD std::string* release_platform();
+  void set_allocated_platform(std::string* platform);
+  private:
+  const std::string& _internal_platform() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
+  std::string* _internal_mutable_platform();
+  public:
+
+  // .Version Rsh_version = 1;
+  bool has_rsh_version() const;
+  private:
+  bool _internal_has_rsh_version() const;
+  public:
+  void clear_rsh_version();
+  const ::Version& rsh_version() const;
+  PROTOBUF_NODISCARD ::Version* release_rsh_version();
+  ::Version* mutable_rsh_version();
+  void set_allocated_rsh_version(::Version* rsh_version);
+  private:
+  const ::Version& _internal_rsh_version() const;
+  ::Version* _internal_mutable_rsh_version();
+  public:
+  void unsafe_arena_set_allocated_rsh_version(
+      ::Version* rsh_version);
+  ::Version* unsafe_arena_release_rsh_version();
+
+  // .Version R_version = 2;
+  bool has_r_version() const;
+  private:
+  bool _internal_has_r_version() const;
+  public:
+  void clear_r_version();
+  const ::Version& r_version() const;
+  PROTOBUF_NODISCARD ::Version* release_r_version();
+  ::Version* mutable_r_version();
+  void set_allocated_r_version(::Version* r_version);
+  private:
+  const ::Version& _internal_r_version() const;
+  ::Version* _internal_mutable_r_version();
+  public:
+  void unsafe_arena_set_allocated_r_version(
+      ::Version* r_version);
+  ::Version* unsafe_arena_release_r_version();
+
+  // @@protoc_insertion_point(class_scope:InitRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> package_hash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
+    ::Version* rsh_version_;
+    ::Version* r_version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class InitResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:InitResponse) */ {
+ public:
+  inline InitResponse() : InitResponse(nullptr) {}
+  explicit PROTOBUF_CONSTEXPR InitResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  InitResponse(const InitResponse& from);
+  InitResponse(InitResponse&& from) noexcept
+    : InitResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline InitResponse& operator=(const InitResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline InitResponse& operator=(InitResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const InitResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const InitResponse* internal_default_instance() {
+    return reinterpret_cast<const InitResponse*>(
+               &_InitResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(InitResponse& a, InitResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(InitResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(InitResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  InitResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<InitResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const InitResponse& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const InitResponse& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "InitResponse";
+  }
+  protected:
+  explicit InitResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:InitResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+  };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CompileRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CompileRequest) */ {
+ public:
+  inline CompileRequest() : CompileRequest(nullptr) {}
+  ~CompileRequest() override;
+  explicit PROTOBUF_CONSTEXPR CompileRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CompileRequest(const CompileRequest& from);
+  CompileRequest(CompileRequest&& from) noexcept
+    : CompileRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline CompileRequest& operator=(const CompileRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CompileRequest& operator=(CompileRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompileRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CompileRequest* internal_default_instance() {
+    return reinterpret_cast<const CompileRequest*>(
+               &_CompileRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(CompileRequest& a, CompileRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CompileRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CompileRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CompileRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CompileRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CompileRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompileRequest& from) {
+    CompileRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CompileRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CompileRequest";
+  }
+  protected:
+  explicit CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionFieldNumber = 2,
+    kContextFieldNumber = 6,
+    kEnvironmentFieldNumber = 7,
+    kTierFieldNumber = 4,
+    kOptimizationLevelFieldNumber = 5,
+  };
+  // .Function function = 2;
+  bool has_function() const;
+  private:
+  bool _internal_has_function() const;
+  public:
+  void clear_function();
+  const ::Function& function() const;
+  PROTOBUF_NODISCARD ::Function* release_function();
+  ::Function* mutable_function();
+  void set_allocated_function(::Function* function);
+  private:
+  const ::Function& _internal_function() const;
+  ::Function* _internal_mutable_function();
+  public:
+  void unsafe_arena_set_allocated_function(
+      ::Function* function);
+  ::Function* unsafe_arena_release_function();
+
+  // optional .Context context = 6;
+  bool has_context() const;
+  private:
+  bool _internal_has_context() const;
+  public:
+  void clear_context();
+  const ::Context& context() const;
+  PROTOBUF_NODISCARD ::Context* release_context();
+  ::Context* mutable_context();
+  void set_allocated_context(::Context* context);
+  private:
+  const ::Context& _internal_context() const;
+  ::Context* _internal_mutable_context();
+  public:
+  void unsafe_arena_set_allocated_context(
+      ::Context* context);
+  ::Context* unsafe_arena_release_context();
+
+  // optional .Environment environment = 7;
+  bool has_environment() const;
+  private:
+  bool _internal_has_environment() const;
+  public:
+  void clear_environment();
+  const ::Environment& environment() const;
+  PROTOBUF_NODISCARD ::Environment* release_environment();
+  ::Environment* mutable_environment();
+  void set_allocated_environment(::Environment* environment);
+  private:
+  const ::Environment& _internal_environment() const;
+  ::Environment* _internal_mutable_environment();
+  public:
+  void unsafe_arena_set_allocated_environment(
+      ::Environment* environment);
+  ::Environment* unsafe_arena_release_environment();
+
+  // optional .Tier tier = 4;
+  bool has_tier() const;
+  private:
+  bool _internal_has_tier() const;
+  public:
+  void clear_tier();
+  ::Tier tier() const;
+  void set_tier(::Tier value);
+  private:
+  ::Tier _internal_tier() const;
+  void _internal_set_tier(::Tier value);
+  public:
+
+  // optional int32 optimization_level = 5;
+  bool has_optimization_level() const;
+  private:
+  bool _internal_has_optimization_level() const;
+  public:
+  void clear_optimization_level();
+  int32_t optimization_level() const;
+  void set_optimization_level(int32_t value);
+  private:
+  int32_t _internal_optimization_level() const;
+  void _internal_set_optimization_level(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CompileRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::Function* function_;
+    ::Context* context_;
+    ::Environment* environment_;
+    int tier_;
+    int32_t optimization_level_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CompileResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CompileResponse) */ {
+ public:
+  inline CompileResponse() : CompileResponse(nullptr) {}
+  ~CompileResponse() override;
+  explicit PROTOBUF_CONSTEXPR CompileResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CompileResponse(const CompileResponse& from);
+  CompileResponse(CompileResponse&& from) noexcept
+    : CompileResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline CompileResponse& operator=(const CompileResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CompileResponse& operator=(CompileResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompileResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CompileResponse* internal_default_instance() {
+    return reinterpret_cast<const CompileResponse*>(
+               &_CompileResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(CompileResponse& a, CompileResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CompileResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CompileResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CompileResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CompileResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CompileResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompileResponse& from) {
+    CompileResponse::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CompileResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CompileResponse";
+  }
+  protected:
+  explicit CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHashFieldNumber = 1,
+    kCodeFieldNumber = 3,
+    kConstantPoolFieldNumber = 4,
+    kTierFieldNumber = 2,
+  };
+  // bytes hash = 1;
+  void clear_hash();
+  const std::string& hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hash();
+  PROTOBUF_NODISCARD std::string* release_hash();
+  void set_allocated_hash(std::string* hash);
+  private:
+  const std::string& _internal_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
+  std::string* _internal_mutable_hash();
+  public:
+
+  // optional bytes code = 3;
+  bool has_code() const;
+  private:
+  bool _internal_has_code() const;
+  public:
+  void clear_code();
+  const std::string& code() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_code(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_code();
+  PROTOBUF_NODISCARD std::string* release_code();
+  void set_allocated_code(std::string* code);
+  private:
+  const std::string& _internal_code() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_code(const std::string& value);
+  std::string* _internal_mutable_code();
+  public:
+
+  // optional bytes constant_pool = 4;
+  bool has_constant_pool() const;
+  private:
+  bool _internal_has_constant_pool() const;
+  public:
+  void clear_constant_pool();
+  const std::string& constant_pool() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_constant_pool(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_constant_pool();
+  PROTOBUF_NODISCARD std::string* release_constant_pool();
+  void set_allocated_constant_pool(std::string* constant_pool);
+  private:
+  const std::string& _internal_constant_pool() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_constant_pool(const std::string& value);
+  std::string* _internal_mutable_constant_pool();
+  public:
+
+  // .Tier tier = 2;
+  void clear_tier();
+  ::Tier tier() const;
+  void set_tier(::Tier value);
+  private:
+  ::Tier _internal_tier() const;
+  void _internal_set_tier(::Tier value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CompileResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr code_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constant_pool_;
+    int tier_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Function final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Function) */ {
+ public:
+  inline Function() : Function(nullptr) {}
+  ~Function() override;
+  explicit PROTOBUF_CONSTEXPR Function(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Function(const Function& from);
+  Function(Function&& from) noexcept
+    : Function() {
+    *this = ::std::move(from);
+  }
+
+  inline Function& operator=(const Function& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Function& operator=(Function&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Function& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Function* internal_default_instance() {
+    return reinterpret_cast<const Function*>(
+               &_Function_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(Function& a, Function& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Function* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Function* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Function* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Function>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Function& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Function& from) {
+    Function::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Function* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Function";
+  }
+  protected:
+  explicit Function(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPackageHashFieldNumber = 1,
+    kNameFieldNumber = 2,
+    kHashFieldNumber = 3,
+    kBodyFieldNumber = 4,
+  };
+  // bytes package_hash = 1;
+  void clear_package_hash();
+  const std::string& package_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_package_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_package_hash();
+  PROTOBUF_NODISCARD std::string* release_package_hash();
+  void set_allocated_package_hash(std::string* package_hash);
+  private:
+  const std::string& _internal_package_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_hash(const std::string& value);
+  std::string* _internal_mutable_package_hash();
+  public:
+
+  // string name = 2;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // bytes hash = 3;
+  void clear_hash();
+  const std::string& hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hash();
+  PROTOBUF_NODISCARD std::string* release_hash();
+  void set_allocated_hash(std::string* hash);
+  private:
+  const std::string& _internal_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
+  std::string* _internal_mutable_hash();
+  public:
+
+  // optional bytes body = 4;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // @@protoc_insertion_point(class_scope:Function)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_hash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:FunctionRequest) */ {
+ public:
+  inline FunctionRequest() : FunctionRequest(nullptr) {}
+  ~FunctionRequest() override;
+  explicit PROTOBUF_CONSTEXPR FunctionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionRequest(const FunctionRequest& from);
+  FunctionRequest(FunctionRequest&& from) noexcept
+    : FunctionRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionRequest& operator=(const FunctionRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionRequest& operator=(FunctionRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionRequest* internal_default_instance() {
+    return reinterpret_cast<const FunctionRequest*>(
+               &_FunctionRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(FunctionRequest& a, FunctionRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FunctionRequest& from) {
+    FunctionRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "FunctionRequest";
+  }
+  protected:
+  explicit FunctionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHashFieldNumber = 1,
+  };
+  // bytes hash = 1;
+  void clear_hash();
+  const std::string& hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hash();
+  PROTOBUF_NODISCARD std::string* release_hash();
+  void set_allocated_hash(std::string* hash);
+  private:
+  const std::string& _internal_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
+  std::string* _internal_mutable_hash();
+  public:
+
+  // @@protoc_insertion_point(class_scope:FunctionRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Environment_ValuesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Environment_ValuesEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Environment_ValuesEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> SuperType;
+  Environment_ValuesEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR Environment_ValuesEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit Environment_ValuesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const Environment_ValuesEntry_DoNotUse& other);
+  static const Environment_ValuesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Environment_ValuesEntry_DoNotUse*>(&_Environment_ValuesEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "Environment.ValuesEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_messages_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class Environment final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Environment) */ {
+ public:
+  inline Environment() : Environment(nullptr) {}
+  ~Environment() override;
+  explicit PROTOBUF_CONSTEXPR Environment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Environment(const Environment& from);
+  Environment(Environment&& from) noexcept
+    : Environment() {
+    *this = ::std::move(from);
+  }
+
+  inline Environment& operator=(const Environment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Environment& operator=(Environment&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Environment& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Environment* internal_default_instance() {
+    return reinterpret_cast<const Environment*>(
+               &_Environment_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(Environment& a, Environment& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Environment* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Environment* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Environment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Environment>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Environment& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Environment& from) {
+    Environment::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Environment* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Environment";
+  }
+  protected:
+  explicit Environment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesFieldNumber = 1,
+  };
+  // map<string, bytes> values = 1;
+  int values_size() const;
+  private:
+  int _internal_values_size() const;
+  public:
+  void clear_values();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      _internal_values() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      _internal_mutable_values();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      values() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      mutable_values();
+
+  // @@protoc_insertion_point(class_scope:Environment)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        Environment_ValuesEntry_DoNotUse,
+        std::string, std::string,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> values_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ValueRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ValueRequest) */ {
+ public:
+  inline ValueRequest() : ValueRequest(nullptr) {}
+  ~ValueRequest() override;
+  explicit PROTOBUF_CONSTEXPR ValueRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ValueRequest(const ValueRequest& from);
+  ValueRequest(ValueRequest&& from) noexcept
+    : ValueRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ValueRequest& operator=(const ValueRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ValueRequest& operator=(ValueRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ValueRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ValueRequest* internal_default_instance() {
+    return reinterpret_cast<const ValueRequest*>(
+               &_ValueRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(ValueRequest& a, ValueRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ValueRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ValueRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ValueRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ValueRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ValueRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ValueRequest& from) {
+    ValueRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ValueRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "ValueRequest";
+  }
+  protected:
+  explicit ValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHashFieldNumber = 1,
+  };
+  // repeated bytes hash = 1;
+  int hash_size() const;
+  private:
+  int _internal_hash_size() const;
+  public:
+  void clear_hash();
+  const std::string& hash(int index) const;
+  std::string* mutable_hash(int index);
+  void set_hash(int index, const std::string& value);
+  void set_hash(int index, std::string&& value);
+  void set_hash(int index, const char* value);
+  void set_hash(int index, const void* value, size_t size);
+  std::string* add_hash();
+  void add_hash(const std::string& value);
+  void add_hash(std::string&& value);
+  void add_hash(const char* value);
+  void add_hash(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& hash() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_hash();
+  private:
+  const std::string& _internal_hash(int index) const;
+  std::string* _internal_add_hash();
+  public:
+
+  // @@protoc_insertion_point(class_scope:ValueRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> hash_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Value) */ {
+ public:
+  inline Value() : Value(nullptr) {}
+  ~Value() override;
+  explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Value(const Value& from);
+  Value(Value&& from) noexcept
+    : Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Value& operator=(const Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Value& operator=(Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Value& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Value* internal_default_instance() {
+    return reinterpret_cast<const Value*>(
+               &_Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(Value& a, Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Value& from) {
+    Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Value";
+  }
+  protected:
+  explicit Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHashFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // bytes hash = 1;
+  void clear_hash();
+  const std::string& hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hash();
+  PROTOBUF_NODISCARD std::string* release_hash();
+  void set_allocated_hash(std::string* hash);
+  private:
+  const std::string& _internal_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
+  std::string* _internal_mutable_hash();
+  public:
+
+  // bytes value = 2;
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:Value)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Values final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Values) */ {
+ public:
+  inline Values() : Values(nullptr) {}
+  ~Values() override;
+  explicit PROTOBUF_CONSTEXPR Values(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Values(const Values& from);
+  Values(Values&& from) noexcept
+    : Values() {
+    *this = ::std::move(from);
+  }
+
+  inline Values& operator=(const Values& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Values& operator=(Values&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Values& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Values* internal_default_instance() {
+    return reinterpret_cast<const Values*>(
+               &_Values_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(Values& a, Values& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Values* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Values* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Values* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Values>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Values& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Values& from) {
+    Values::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Values* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Values";
+  }
+  protected:
+  explicit Values(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesFieldNumber = 1,
+  };
+  // repeated .Value values = 1;
+  int values_size() const;
+  private:
+  int _internal_values_size() const;
+  public:
+  void clear_values();
+  ::Value* mutable_values(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >*
+      mutable_values();
+  private:
+  const ::Value& _internal_values(int index) const;
+  ::Value* _internal_add_values();
+  public:
+  const ::Value& values(int index) const;
+  ::Value* add_values();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >&
+      values() const;
+
+  // @@protoc_insertion_point(class_scope:Values)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value > values_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Empty final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:Empty) */ {
+ public:
+  inline Empty() : Empty(nullptr) {}
+  explicit PROTOBUF_CONSTEXPR Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Empty(const Empty& from);
+  Empty(Empty&& from) noexcept
+    : Empty() {
+    *this = ::std::move(from);
+  }
+
+  inline Empty& operator=(const Empty& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Empty& operator=(Empty&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Empty& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Empty* internal_default_instance() {
+    return reinterpret_cast<const Empty*>(
+               &_Empty_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(Empty& a, Empty& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Empty* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Empty* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Empty>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Empty& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Empty& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Empty";
+  }
+  protected:
+  explicit Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:Empty)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+  };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CallContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CallContext) */ {
+ public:
+  inline CallContext() : CallContext(nullptr) {}
+  ~CallContext() override;
+  explicit PROTOBUF_CONSTEXPR CallContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CallContext(const CallContext& from);
+  CallContext(CallContext&& from) noexcept
+    : CallContext() {
+    *this = ::std::move(from);
+  }
+
+  inline CallContext& operator=(const CallContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CallContext& operator=(CallContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CallContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CallContext* internal_default_instance() {
+    return reinterpret_cast<const CallContext*>(
+               &_CallContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(CallContext& a, CallContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CallContext* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CallContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CallContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CallContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CallContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CallContext& from) {
+    CallContext::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CallContext* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CallContext";
+  }
+  protected:
+  explicit CallContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgsStaticallyMatchedFieldNumber = 1,
+    kCorrectNumberOfArgsFieldNumber = 2,
+    kCorrectOrderOfArgsFieldNumber = 3,
+    kNoMissingArgsFieldNumber = 4,
+  };
+  // bool args_statically_matched = 1;
+  void clear_args_statically_matched();
+  bool args_statically_matched() const;
+  void set_args_statically_matched(bool value);
+  private:
+  bool _internal_args_statically_matched() const;
+  void _internal_set_args_statically_matched(bool value);
+  public:
+
+  // bool correct_number_of_args = 2;
+  void clear_correct_number_of_args();
+  bool correct_number_of_args() const;
+  void set_correct_number_of_args(bool value);
+  private:
+  bool _internal_correct_number_of_args() const;
+  void _internal_set_correct_number_of_args(bool value);
+  public:
+
+  // bool correct_order_of_args = 3;
+  void clear_correct_order_of_args();
+  bool correct_order_of_args() const;
+  void set_correct_order_of_args(bool value);
+  private:
+  bool _internal_correct_order_of_args() const;
+  void _internal_set_correct_order_of_args(bool value);
+  public:
+
+  // bool no_missing_args = 4;
+  void clear_no_missing_args();
+  bool no_missing_args() const;
+  void set_no_missing_args(bool value);
+  private:
+  bool _internal_no_missing_args() const;
+  void _internal_set_no_missing_args(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CallContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    bool args_statically_matched_;
+    bool correct_number_of_args_;
+    bool correct_order_of_args_;
+    bool no_missing_args_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ArgumentContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ArgumentContext) */ {
+ public:
+  inline ArgumentContext() : ArgumentContext(nullptr) {}
+  ~ArgumentContext() override;
+  explicit PROTOBUF_CONSTEXPR ArgumentContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ArgumentContext(const ArgumentContext& from);
+  ArgumentContext(ArgumentContext&& from) noexcept
+    : ArgumentContext() {
+    *this = ::std::move(from);
+  }
+
+  inline ArgumentContext& operator=(const ArgumentContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ArgumentContext& operator=(ArgumentContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ArgumentContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ArgumentContext* internal_default_instance() {
+    return reinterpret_cast<const ArgumentContext*>(
+               &_ArgumentContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(ArgumentContext& a, ArgumentContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ArgumentContext* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ArgumentContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ArgumentContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ArgumentContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ArgumentContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ArgumentContext& from) {
+    ArgumentContext::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ArgumentContext* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "ArgumentContext";
+  }
+  protected:
+  explicit ArgumentContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEagerFieldNumber = 1,
+    kReflectionFieldNumber = 2,
+    kObjectFieldNumber = 3,
+    kTypeFieldNumber = 4,
+  };
+  // bool eager = 1;
+  void clear_eager();
+  bool eager() const;
+  void set_eager(bool value);
+  private:
+  bool _internal_eager() const;
+  void _internal_set_eager(bool value);
+  public:
+
+  // bool reflection = 2;
+  void clear_reflection();
+  bool reflection() const;
+  void set_reflection(bool value);
+  private:
+  bool _internal_reflection() const;
+  void _internal_set_reflection(bool value);
+  public:
+
+  // bool object = 3;
+  void clear_object();
+  bool object() const;
+  void set_object(bool value);
+  private:
+  bool _internal_object() const;
+  void _internal_set_object(bool value);
+  public:
+
+  // optional .Type type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::Type type() const;
+  void set_type(::Type value);
+  private:
+  ::Type _internal_type() const;
+  void _internal_set_type(::Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:ArgumentContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    bool eager_;
+    bool reflection_;
+    bool object_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Context final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Context) */ {
+ public:
+  inline Context() : Context(nullptr) {}
+  ~Context() override;
+  explicit PROTOBUF_CONSTEXPR Context(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Context(const Context& from);
+  Context(Context&& from) noexcept
+    : Context() {
+    *this = ::std::move(from);
+  }
+
+  inline Context& operator=(const Context& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Context& operator=(Context&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Context& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Context* internal_default_instance() {
+    return reinterpret_cast<const Context*>(
+               &_Context_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(Context& a, Context& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Context* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Context* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Context* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Context>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Context& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Context& from) {
+    Context::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Context* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Context";
+  }
+  protected:
+  explicit Context(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgumentContextFieldNumber = 2,
+    kCallContextFieldNumber = 1,
+  };
+  // repeated .ArgumentContext argument_context = 2;
+  int argument_context_size() const;
+  private:
+  int _internal_argument_context_size() const;
+  public:
+  void clear_argument_context();
+  ::ArgumentContext* mutable_argument_context(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >*
+      mutable_argument_context();
+  private:
+  const ::ArgumentContext& _internal_argument_context(int index) const;
+  ::ArgumentContext* _internal_add_argument_context();
+  public:
+  const ::ArgumentContext& argument_context(int index) const;
+  ::ArgumentContext* add_argument_context();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >&
+      argument_context() const;
+
+  // .CallContext call_context = 1;
+  bool has_call_context() const;
+  private:
+  bool _internal_has_call_context() const;
+  public:
+  void clear_call_context();
+  const ::CallContext& call_context() const;
+  PROTOBUF_NODISCARD ::CallContext* release_call_context();
+  ::CallContext* mutable_call_context();
+  void set_allocated_call_context(::CallContext* call_context);
+  private:
+  const ::CallContext& _internal_call_context() const;
+  ::CallContext* _internal_mutable_call_context();
+  public:
+  void unsafe_arena_set_allocated_call_context(
+      ::CallContext* call_context);
+  ::CallContext* unsafe_arena_release_call_context();
+
+  // @@protoc_insertion_point(class_scope:Context)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext > argument_context_;
+    ::CallContext* call_context_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContextRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ContextRequest) */ {
+ public:
+  inline ContextRequest() : ContextRequest(nullptr) {}
+  ~ContextRequest() override;
+  explicit PROTOBUF_CONSTEXPR ContextRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContextRequest(const ContextRequest& from);
+  ContextRequest(ContextRequest&& from) noexcept
+    : ContextRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ContextRequest& operator=(const ContextRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContextRequest& operator=(ContextRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContextRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContextRequest* internal_default_instance() {
+    return reinterpret_cast<const ContextRequest*>(
+               &_ContextRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(ContextRequest& a, ContextRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContextRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContextRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ContextRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ContextRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContextRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ContextRequest& from) {
+    ContextRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContextRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "ContextRequest";
+  }
+  protected:
+  explicit ContextRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionFieldNumber = 1,
+  };
+  // .Function function = 1;
+  bool has_function() const;
+  private:
+  bool _internal_has_function() const;
+  public:
+  void clear_function();
+  const ::Function& function() const;
+  PROTOBUF_NODISCARD ::Function* release_function();
+  ::Function* mutable_function();
+  void set_allocated_function(::Function* function);
+  private:
+  const ::Function& _internal_function() const;
+  ::Function* _internal_mutable_function();
+  public:
+  void unsafe_arena_set_allocated_function(
+      ::Function* function);
+  ::Function* unsafe_arena_release_function();
+
+  // @@protoc_insertion_point(class_scope:ContextRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::Function* function_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TestFeedback final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TestFeedback) */ {
+ public:
+  inline TestFeedback() : TestFeedback(nullptr) {}
+  ~TestFeedback() override;
+  explicit PROTOBUF_CONSTEXPR TestFeedback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TestFeedback(const TestFeedback& from);
+  TestFeedback(TestFeedback&& from) noexcept
+    : TestFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline TestFeedback& operator=(const TestFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TestFeedback& operator=(TestFeedback&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TestFeedback& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TestFeedback* internal_default_instance() {
+    return reinterpret_cast<const TestFeedback*>(
+               &_TestFeedback_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(TestFeedback& a, TestFeedback& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TestFeedback* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TestFeedback* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TestFeedback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TestFeedback>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TestFeedback& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TestFeedback& from) {
+    TestFeedback::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TestFeedback* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "TestFeedback";
+  }
+  protected:
+  explicit TestFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTestLatticeFieldNumber = 1,
+  };
+  // .TestLattice test_lattice = 1;
+  void clear_test_lattice();
+  ::TestLattice test_lattice() const;
+  void set_test_lattice(::TestLattice value);
+  private:
+  ::TestLattice _internal_test_lattice() const;
+  void _internal_set_test_lattice(::TestLattice value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:TestFeedback)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int test_lattice_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CallFeedback final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CallFeedback) */ {
+ public:
+  inline CallFeedback() : CallFeedback(nullptr) {}
+  ~CallFeedback() override;
+  explicit PROTOBUF_CONSTEXPR CallFeedback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CallFeedback(const CallFeedback& from);
+  CallFeedback(CallFeedback&& from) noexcept
+    : CallFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline CallFeedback& operator=(const CallFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CallFeedback& operator=(CallFeedback&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CallFeedback& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CallFeedback* internal_default_instance() {
+    return reinterpret_cast<const CallFeedback*>(
+               &_CallFeedback_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(CallFeedback& a, CallFeedback& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CallFeedback* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CallFeedback* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CallFeedback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CallFeedback>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CallFeedback& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CallFeedback& from) {
+    CallFeedback::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CallFeedback* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "CallFeedback";
+  }
+  protected:
+  explicit CallFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCalleeHashFieldNumber = 2,
+    kNCallsFieldNumber = 1,
+  };
+  // bytes callee_hash = 2;
+  void clear_callee_hash();
+  const std::string& callee_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_callee_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_callee_hash();
+  PROTOBUF_NODISCARD std::string* release_callee_hash();
+  void set_allocated_callee_hash(std::string* callee_hash);
+  private:
+  const std::string& _internal_callee_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callee_hash(const std::string& value);
+  std::string* _internal_mutable_callee_hash();
+  public:
+
+  // int64 n_calls = 1;
+  void clear_n_calls();
+  int64_t n_calls() const;
+  void set_n_calls(int64_t value);
+  private:
+  int64_t _internal_n_calls() const;
+  void _internal_set_n_calls(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:CallFeedback)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callee_hash_;
+    int64_t n_calls_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ValueFeedback final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ValueFeedback) */ {
+ public:
+  inline ValueFeedback() : ValueFeedback(nullptr) {}
+  ~ValueFeedback() override;
+  explicit PROTOBUF_CONSTEXPR ValueFeedback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ValueFeedback(const ValueFeedback& from);
+  ValueFeedback(ValueFeedback&& from) noexcept
+    : ValueFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline ValueFeedback& operator=(const ValueFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ValueFeedback& operator=(ValueFeedback&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ValueFeedback& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ValueFeedback* internal_default_instance() {
+    return reinterpret_cast<const ValueFeedback*>(
+               &_ValueFeedback_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(ValueFeedback& a, ValueFeedback& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ValueFeedback* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ValueFeedback* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ValueFeedback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ValueFeedback>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ValueFeedback& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ValueFeedback& from) {
+    ValueFeedback::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ValueFeedback* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "ValueFeedback";
+  }
+  protected:
+  explicit ValueFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kScalarFieldNumber = 1,
+    kObjectFieldNumber = 2,
+    kAccessedAttributesFieldNumber = 3,
+    kVectorizableFieldNumber = 4,
+    kIsPromiseFieldNumber = 5,
+  };
+  // bool scalar = 1;
+  void clear_scalar();
+  bool scalar() const;
+  void set_scalar(bool value);
+  private:
+  bool _internal_scalar() const;
+  void _internal_set_scalar(bool value);
+  public:
+
+  // bool object = 2;
+  void clear_object();
+  bool object() const;
+  void set_object(bool value);
+  private:
+  bool _internal_object() const;
+  void _internal_set_object(bool value);
+  public:
+
+  // bool accessed_attributes = 3;
+  void clear_accessed_attributes();
+  bool accessed_attributes() const;
+  void set_accessed_attributes(bool value);
+  private:
+  bool _internal_accessed_attributes() const;
+  void _internal_set_accessed_attributes(bool value);
+  public:
+
+  // bool vectorizable = 4;
+  void clear_vectorizable();
+  bool vectorizable() const;
+  void set_vectorizable(bool value);
+  private:
+  bool _internal_vectorizable() const;
+  void _internal_set_vectorizable(bool value);
+  public:
+
+  // bool is_promise = 5;
+  void clear_is_promise();
+  bool is_promise() const;
+  void set_is_promise(bool value);
+  private:
+  bool _internal_is_promise() const;
+  void _internal_set_is_promise(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:ValueFeedback)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    bool scalar_;
+    bool object_;
+    bool accessed_attributes_;
+    bool vectorizable_;
+    bool is_promise_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TypeFeedback_Feedback final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TypeFeedback.Feedback) */ {
+ public:
+  inline TypeFeedback_Feedback() : TypeFeedback_Feedback(nullptr) {}
+  ~TypeFeedback_Feedback() override;
+  explicit PROTOBUF_CONSTEXPR TypeFeedback_Feedback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TypeFeedback_Feedback(const TypeFeedback_Feedback& from);
+  TypeFeedback_Feedback(TypeFeedback_Feedback&& from) noexcept
+    : TypeFeedback_Feedback() {
+    *this = ::std::move(from);
+  }
+
+  inline TypeFeedback_Feedback& operator=(const TypeFeedback_Feedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TypeFeedback_Feedback& operator=(TypeFeedback_Feedback&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TypeFeedback_Feedback& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FeedbackCase {
+    kTestFeedback = 1,
+    kCallFeedback = 2,
+    kValueFeedback = 3,
+    FEEDBACK_NOT_SET = 0,
+  };
+
+  static inline const TypeFeedback_Feedback* internal_default_instance() {
+    return reinterpret_cast<const TypeFeedback_Feedback*>(
+               &_TypeFeedback_Feedback_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(TypeFeedback_Feedback& a, TypeFeedback_Feedback& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TypeFeedback_Feedback* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TypeFeedback_Feedback* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TypeFeedback_Feedback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TypeFeedback_Feedback>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TypeFeedback_Feedback& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TypeFeedback_Feedback& from) {
+    TypeFeedback_Feedback::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TypeFeedback_Feedback* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "TypeFeedback.Feedback";
+  }
+  protected:
+  explicit TypeFeedback_Feedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTestFeedbackFieldNumber = 1,
+    kCallFeedbackFieldNumber = 2,
+    kValueFeedbackFieldNumber = 3,
+  };
+  // .TestFeedback test_feedback = 1;
+  bool has_test_feedback() const;
+  private:
+  bool _internal_has_test_feedback() const;
+  public:
+  void clear_test_feedback();
+  const ::TestFeedback& test_feedback() const;
+  PROTOBUF_NODISCARD ::TestFeedback* release_test_feedback();
+  ::TestFeedback* mutable_test_feedback();
+  void set_allocated_test_feedback(::TestFeedback* test_feedback);
+  private:
+  const ::TestFeedback& _internal_test_feedback() const;
+  ::TestFeedback* _internal_mutable_test_feedback();
+  public:
+  void unsafe_arena_set_allocated_test_feedback(
+      ::TestFeedback* test_feedback);
+  ::TestFeedback* unsafe_arena_release_test_feedback();
+
+  // .CallFeedback call_feedback = 2;
+  bool has_call_feedback() const;
+  private:
+  bool _internal_has_call_feedback() const;
+  public:
+  void clear_call_feedback();
+  const ::CallFeedback& call_feedback() const;
+  PROTOBUF_NODISCARD ::CallFeedback* release_call_feedback();
+  ::CallFeedback* mutable_call_feedback();
+  void set_allocated_call_feedback(::CallFeedback* call_feedback);
+  private:
+  const ::CallFeedback& _internal_call_feedback() const;
+  ::CallFeedback* _internal_mutable_call_feedback();
+  public:
+  void unsafe_arena_set_allocated_call_feedback(
+      ::CallFeedback* call_feedback);
+  ::CallFeedback* unsafe_arena_release_call_feedback();
+
+  // .ValueFeedback value_feedback = 3;
+  bool has_value_feedback() const;
+  private:
+  bool _internal_has_value_feedback() const;
+  public:
+  void clear_value_feedback();
+  const ::ValueFeedback& value_feedback() const;
+  PROTOBUF_NODISCARD ::ValueFeedback* release_value_feedback();
+  ::ValueFeedback* mutable_value_feedback();
+  void set_allocated_value_feedback(::ValueFeedback* value_feedback);
+  private:
+  const ::ValueFeedback& _internal_value_feedback() const;
+  ::ValueFeedback* _internal_mutable_value_feedback();
+  public:
+  void unsafe_arena_set_allocated_value_feedback(
+      ::ValueFeedback* value_feedback);
+  ::ValueFeedback* unsafe_arena_release_value_feedback();
+
+  void clear_feedback();
+  FeedbackCase feedback_case() const;
+  // @@protoc_insertion_point(class_scope:TypeFeedback.Feedback)
+ private:
+  class _Internal;
+  void set_has_test_feedback();
+  void set_has_call_feedback();
+  void set_has_value_feedback();
+
+  inline bool has_feedback() const;
+  inline void clear_has_feedback();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union FeedbackUnion {
+      constexpr FeedbackUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::TestFeedback* test_feedback_;
+      ::CallFeedback* call_feedback_;
+      ::ValueFeedback* value_feedback_;
+    } feedback_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TypeFeedback_TypesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<TypeFeedback_TypesEntry_DoNotUse, 
+    int64_t, ::TypeFeedback_Feedback,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<TypeFeedback_TypesEntry_DoNotUse, 
+    int64_t, ::TypeFeedback_Feedback,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  TypeFeedback_TypesEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR TypeFeedback_TypesEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit TypeFeedback_TypesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const TypeFeedback_TypesEntry_DoNotUse& other);
+  static const TypeFeedback_TypesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const TypeFeedback_TypesEntry_DoNotUse*>(&_TypeFeedback_TypesEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_messages_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class TypeFeedback final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TypeFeedback) */ {
+ public:
+  inline TypeFeedback() : TypeFeedback(nullptr) {}
+  ~TypeFeedback() override;
+  explicit PROTOBUF_CONSTEXPR TypeFeedback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TypeFeedback(const TypeFeedback& from);
+  TypeFeedback(TypeFeedback&& from) noexcept
+    : TypeFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline TypeFeedback& operator=(const TypeFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TypeFeedback& operator=(TypeFeedback&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TypeFeedback& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TypeFeedback* internal_default_instance() {
+    return reinterpret_cast<const TypeFeedback*>(
+               &_TypeFeedback_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(TypeFeedback& a, TypeFeedback& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TypeFeedback* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TypeFeedback* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TypeFeedback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TypeFeedback>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TypeFeedback& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TypeFeedback& from) {
+    TypeFeedback::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TypeFeedback* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "TypeFeedback";
+  }
+  protected:
+  explicit TypeFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef TypeFeedback_Feedback Feedback;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypesFieldNumber = 2,
+  };
+  // map<int64, .TypeFeedback.Feedback> types = 2;
+  int types_size() const;
+  private:
+  int _internal_types_size() const;
+  public:
+  void clear_types();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+      _internal_types() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+      _internal_mutable_types();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+      types() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+      mutable_types();
+
+  // @@protoc_insertion_point(class_scope:TypeFeedback)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        TypeFeedback_TypesEntry_DoNotUse,
+        int64_t, ::TypeFeedback_Feedback,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> types_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FeedbackRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:FeedbackRequest) */ {
+ public:
+  inline FeedbackRequest() : FeedbackRequest(nullptr) {}
+  ~FeedbackRequest() override;
+  explicit PROTOBUF_CONSTEXPR FeedbackRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FeedbackRequest(const FeedbackRequest& from);
+  FeedbackRequest(FeedbackRequest&& from) noexcept
+    : FeedbackRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline FeedbackRequest& operator=(const FeedbackRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FeedbackRequest& operator=(FeedbackRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FeedbackRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FeedbackRequest* internal_default_instance() {
+    return reinterpret_cast<const FeedbackRequest*>(
+               &_FeedbackRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(FeedbackRequest& a, FeedbackRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FeedbackRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FeedbackRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FeedbackRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FeedbackRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FeedbackRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FeedbackRequest& from) {
+    FeedbackRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FeedbackRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "FeedbackRequest";
+  }
+  protected:
+  explicit FeedbackRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionFieldNumber = 1,
+  };
+  // .Function function = 1;
+  bool has_function() const;
+  private:
+  bool _internal_has_function() const;
+  public:
+  void clear_function();
+  const ::Function& function() const;
+  PROTOBUF_NODISCARD ::Function* release_function();
+  ::Function* mutable_function();
+  void set_allocated_function(::Function* function);
+  private:
+  const ::Function& _internal_function() const;
+  ::Function* _internal_mutable_function();
+  public:
+  void unsafe_arena_set_allocated_function(
+      ::Function* function);
+  ::Function* unsafe_arena_release_function();
+
+  // @@protoc_insertion_point(class_scope:FeedbackRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::Function* function_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackageSource final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PackageSource) */ {
+ public:
+  inline PackageSource() : PackageSource(nullptr) {}
+  ~PackageSource() override;
+  explicit PROTOBUF_CONSTEXPR PackageSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackageSource(const PackageSource& from);
+  PackageSource(PackageSource&& from) noexcept
+    : PackageSource() {
+    *this = ::std::move(from);
+  }
+
+  inline PackageSource& operator=(const PackageSource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackageSource& operator=(PackageSource&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackageSource& default_instance() {
+    return *internal_default_instance();
+  }
+  enum SourceCase {
+    kRMirror = 2,
+    kGithubUrl = 3,
+    SOURCE_NOT_SET = 0,
+  };
+
+  static inline const PackageSource* internal_default_instance() {
+    return reinterpret_cast<const PackageSource*>(
+               &_PackageSource_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(PackageSource& a, PackageSource& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackageSource* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackageSource* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PackageSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PackageSource>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackageSource& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PackageSource& from) {
+    PackageSource::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackageSource* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "PackageSource";
+  }
+  protected:
+  explicit PackageSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRMirrorFieldNumber = 2,
+    kGithubUrlFieldNumber = 3,
+  };
+  // string r_mirror = 2;
+  bool has_r_mirror() const;
+  private:
+  bool _internal_has_r_mirror() const;
+  public:
+  void clear_r_mirror();
+  const std::string& r_mirror() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_r_mirror(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_r_mirror();
+  PROTOBUF_NODISCARD std::string* release_r_mirror();
+  void set_allocated_r_mirror(std::string* r_mirror);
+  private:
+  const std::string& _internal_r_mirror() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_r_mirror(const std::string& value);
+  std::string* _internal_mutable_r_mirror();
+  public:
+
+  // string github_url = 3;
+  bool has_github_url() const;
+  private:
+  bool _internal_has_github_url() const;
+  public:
+  void clear_github_url();
+  const std::string& github_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_github_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_github_url();
+  PROTOBUF_NODISCARD std::string* release_github_url();
+  void set_allocated_github_url(std::string* github_url);
+  private:
+  const std::string& _internal_github_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_github_url(const std::string& value);
+  std::string* _internal_mutable_github_url();
+  public:
+
+  void clear_source();
+  SourceCase source_case() const;
+  // @@protoc_insertion_point(class_scope:PackageSource)
+ private:
+  class _Internal;
+  void set_has_r_mirror();
+  void set_has_github_url();
+
+  inline bool has_source() const;
+  inline void clear_has_source();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union SourceUnion {
+      constexpr SourceUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr r_mirror_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr github_url_;
+    } source_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Package final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Package) */ {
+ public:
+  inline Package() : Package(nullptr) {}
+  ~Package() override;
+  explicit PROTOBUF_CONSTEXPR Package(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Package(const Package& from);
+  Package(Package&& from) noexcept
+    : Package() {
+    *this = ::std::move(from);
+  }
+
+  inline Package& operator=(const Package& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Package& operator=(Package&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Package& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Package* internal_default_instance() {
+    return reinterpret_cast<const Package*>(
+               &_Package_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(Package& a, Package& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Package* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Package* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Package* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Package>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Package& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Package& from) {
+    Package::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Package* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Package";
+  }
+  protected:
+  explicit Package(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionHashesFieldNumber = 4,
+    kNameFieldNumber = 1,
+    kVersionFieldNumber = 2,
+    kSourceFieldNumber = 5,
+  };
+  // repeated bytes function_hashes = 4;
+  int function_hashes_size() const;
+  private:
+  int _internal_function_hashes_size() const;
+  public:
+  void clear_function_hashes();
+  const std::string& function_hashes(int index) const;
+  std::string* mutable_function_hashes(int index);
+  void set_function_hashes(int index, const std::string& value);
+  void set_function_hashes(int index, std::string&& value);
+  void set_function_hashes(int index, const char* value);
+  void set_function_hashes(int index, const void* value, size_t size);
+  std::string* add_function_hashes();
+  void add_function_hashes(const std::string& value);
+  void add_function_hashes(std::string&& value);
+  void add_function_hashes(const char* value);
+  void add_function_hashes(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& function_hashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_function_hashes();
+  private:
+  const std::string& _internal_function_hashes(int index) const;
+  std::string* _internal_add_function_hashes();
+  public:
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .Version version = 2;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const ::Version& version() const;
+  PROTOBUF_NODISCARD ::Version* release_version();
+  ::Version* mutable_version();
+  void set_allocated_version(::Version* version);
+  private:
+  const ::Version& _internal_version() const;
+  ::Version* _internal_mutable_version();
+  public:
+  void unsafe_arena_set_allocated_version(
+      ::Version* version);
+  ::Version* unsafe_arena_release_version();
+
+  // optional .PackageSource source = 5;
+  bool has_source() const;
+  private:
+  bool _internal_has_source() const;
+  public:
+  void clear_source();
+  const ::PackageSource& source() const;
+  PROTOBUF_NODISCARD ::PackageSource* release_source();
+  ::PackageSource* mutable_source();
+  void set_allocated_source(::PackageSource* source);
+  private:
+  const ::PackageSource& _internal_source() const;
+  ::PackageSource* _internal_mutable_source();
+  public:
+  void unsafe_arena_set_allocated_source(
+      ::PackageSource* source);
+  ::PackageSource* unsafe_arena_release_source();
+
+  // @@protoc_insertion_point(class_scope:Package)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> function_hashes_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::Version* version_;
+    ::PackageSource* source_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackageRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PackageRequest) */ {
+ public:
+  inline PackageRequest() : PackageRequest(nullptr) {}
+  ~PackageRequest() override;
+  explicit PROTOBUF_CONSTEXPR PackageRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackageRequest(const PackageRequest& from);
+  PackageRequest(PackageRequest&& from) noexcept
+    : PackageRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PackageRequest& operator=(const PackageRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackageRequest& operator=(PackageRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackageRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackageRequest* internal_default_instance() {
+    return reinterpret_cast<const PackageRequest*>(
+               &_PackageRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    26;
+
+  friend void swap(PackageRequest& a, PackageRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackageRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackageRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PackageRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PackageRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackageRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const PackageRequest& from) {
+    PackageRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackageRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "PackageRequest";
+  }
+  protected:
+  explicit PackageRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHashFieldNumber = 1,
+  };
+  // bytes hash = 1;
+  void clear_hash();
+  const std::string& hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hash();
+  PROTOBUF_NODISCARD std::string* release_hash();
+  void set_allocated_hash(std::string* hash);
+  private:
+  const std::string& _internal_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
+  std::string* _internal_mutable_hash();
+  public:
+
+  // @@protoc_insertion_point(class_scope:PackageRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Version
+
+// int32 major = 1;
+inline void Version::clear_major() {
+  _impl_.major_ = 0;
+}
+inline int32_t Version::_internal_major() const {
+  return _impl_.major_;
+}
+inline int32_t Version::major() const {
+  // @@protoc_insertion_point(field_get:Version.major)
+  return _internal_major();
+}
+inline void Version::_internal_set_major(int32_t value) {
+  
+  _impl_.major_ = value;
+}
+inline void Version::set_major(int32_t value) {
+  _internal_set_major(value);
+  // @@protoc_insertion_point(field_set:Version.major)
+}
+
+// int32 minor = 2;
+inline void Version::clear_minor() {
+  _impl_.minor_ = 0;
+}
+inline int32_t Version::_internal_minor() const {
+  return _impl_.minor_;
+}
+inline int32_t Version::minor() const {
+  // @@protoc_insertion_point(field_get:Version.minor)
+  return _internal_minor();
+}
+inline void Version::_internal_set_minor(int32_t value) {
+  
+  _impl_.minor_ = value;
+}
+inline void Version::set_minor(int32_t value) {
+  _internal_set_minor(value);
+  // @@protoc_insertion_point(field_set:Version.minor)
+}
+
+// int32 patch = 3;
+inline void Version::clear_patch() {
+  _impl_.patch_ = 0;
+}
+inline int32_t Version::_internal_patch() const {
+  return _impl_.patch_;
+}
+inline int32_t Version::patch() const {
+  // @@protoc_insertion_point(field_get:Version.patch)
+  return _internal_patch();
+}
+inline void Version::_internal_set_patch(int32_t value) {
+  
+  _impl_.patch_ = value;
+}
+inline void Version::set_patch(int32_t value) {
+  _internal_set_patch(value);
+  // @@protoc_insertion_point(field_set:Version.patch)
+}
+
+// -------------------------------------------------------------------
+
+// InitRequest
+
+// .Version Rsh_version = 1;
+inline bool InitRequest::_internal_has_rsh_version() const {
+  return this != internal_default_instance() && _impl_.rsh_version_ != nullptr;
+}
+inline bool InitRequest::has_rsh_version() const {
+  return _internal_has_rsh_version();
+}
+inline void InitRequest::clear_rsh_version() {
+  if (GetArenaForAllocation() == nullptr && _impl_.rsh_version_ != nullptr) {
+    delete _impl_.rsh_version_;
+  }
+  _impl_.rsh_version_ = nullptr;
+}
+inline const ::Version& InitRequest::_internal_rsh_version() const {
+  const ::Version* p = _impl_.rsh_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Version&>(
+      ::_Version_default_instance_);
+}
+inline const ::Version& InitRequest::rsh_version() const {
+  // @@protoc_insertion_point(field_get:InitRequest.Rsh_version)
+  return _internal_rsh_version();
+}
+inline void InitRequest::unsafe_arena_set_allocated_rsh_version(
+    ::Version* rsh_version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rsh_version_);
+  }
+  _impl_.rsh_version_ = rsh_version;
+  if (rsh_version) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:InitRequest.Rsh_version)
+}
+inline ::Version* InitRequest::release_rsh_version() {
+  
+  ::Version* temp = _impl_.rsh_version_;
+  _impl_.rsh_version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Version* InitRequest::unsafe_arena_release_rsh_version() {
+  // @@protoc_insertion_point(field_release:InitRequest.Rsh_version)
+  
+  ::Version* temp = _impl_.rsh_version_;
+  _impl_.rsh_version_ = nullptr;
+  return temp;
+}
+inline ::Version* InitRequest::_internal_mutable_rsh_version() {
+  
+  if (_impl_.rsh_version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Version>(GetArenaForAllocation());
+    _impl_.rsh_version_ = p;
+  }
+  return _impl_.rsh_version_;
+}
+inline ::Version* InitRequest::mutable_rsh_version() {
+  ::Version* _msg = _internal_mutable_rsh_version();
+  // @@protoc_insertion_point(field_mutable:InitRequest.Rsh_version)
+  return _msg;
+}
+inline void InitRequest::set_allocated_rsh_version(::Version* rsh_version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.rsh_version_;
+  }
+  if (rsh_version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rsh_version);
+    if (message_arena != submessage_arena) {
+      rsh_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, rsh_version, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.rsh_version_ = rsh_version;
+  // @@protoc_insertion_point(field_set_allocated:InitRequest.Rsh_version)
+}
+
+// .Version R_version = 2;
+inline bool InitRequest::_internal_has_r_version() const {
+  return this != internal_default_instance() && _impl_.r_version_ != nullptr;
+}
+inline bool InitRequest::has_r_version() const {
+  return _internal_has_r_version();
+}
+inline void InitRequest::clear_r_version() {
+  if (GetArenaForAllocation() == nullptr && _impl_.r_version_ != nullptr) {
+    delete _impl_.r_version_;
+  }
+  _impl_.r_version_ = nullptr;
+}
+inline const ::Version& InitRequest::_internal_r_version() const {
+  const ::Version* p = _impl_.r_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Version&>(
+      ::_Version_default_instance_);
+}
+inline const ::Version& InitRequest::r_version() const {
+  // @@protoc_insertion_point(field_get:InitRequest.R_version)
+  return _internal_r_version();
+}
+inline void InitRequest::unsafe_arena_set_allocated_r_version(
+    ::Version* r_version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.r_version_);
+  }
+  _impl_.r_version_ = r_version;
+  if (r_version) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:InitRequest.R_version)
+}
+inline ::Version* InitRequest::release_r_version() {
+  
+  ::Version* temp = _impl_.r_version_;
+  _impl_.r_version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Version* InitRequest::unsafe_arena_release_r_version() {
+  // @@protoc_insertion_point(field_release:InitRequest.R_version)
+  
+  ::Version* temp = _impl_.r_version_;
+  _impl_.r_version_ = nullptr;
+  return temp;
+}
+inline ::Version* InitRequest::_internal_mutable_r_version() {
+  
+  if (_impl_.r_version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Version>(GetArenaForAllocation());
+    _impl_.r_version_ = p;
+  }
+  return _impl_.r_version_;
+}
+inline ::Version* InitRequest::mutable_r_version() {
+  ::Version* _msg = _internal_mutable_r_version();
+  // @@protoc_insertion_point(field_mutable:InitRequest.R_version)
+  return _msg;
+}
+inline void InitRequest::set_allocated_r_version(::Version* r_version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.r_version_;
+  }
+  if (r_version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(r_version);
+    if (message_arena != submessage_arena) {
+      r_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, r_version, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.r_version_ = r_version;
+  // @@protoc_insertion_point(field_set_allocated:InitRequest.R_version)
+}
+
+// string platform = 3;
+inline void InitRequest::clear_platform() {
+  _impl_.platform_.ClearToEmpty();
+}
+inline const std::string& InitRequest::platform() const {
+  // @@protoc_insertion_point(field_get:InitRequest.platform)
+  return _internal_platform();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void InitRequest::set_platform(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:InitRequest.platform)
+}
+inline std::string* InitRequest::mutable_platform() {
+  std::string* _s = _internal_mutable_platform();
+  // @@protoc_insertion_point(field_mutable:InitRequest.platform)
+  return _s;
+}
+inline const std::string& InitRequest::_internal_platform() const {
+  return _impl_.platform_.Get();
+}
+inline void InitRequest::_internal_set_platform(const std::string& value) {
+  
+  _impl_.platform_.Set(value, GetArenaForAllocation());
+}
+inline std::string* InitRequest::_internal_mutable_platform() {
+  
+  return _impl_.platform_.Mutable(GetArenaForAllocation());
+}
+inline std::string* InitRequest::release_platform() {
+  // @@protoc_insertion_point(field_release:InitRequest.platform)
+  return _impl_.platform_.Release();
+}
+inline void InitRequest::set_allocated_platform(std::string* platform) {
+  if (platform != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.platform_.SetAllocated(platform, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.platform_.IsDefault()) {
+    _impl_.platform_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:InitRequest.platform)
+}
+
+// repeated bytes package_hash = 4;
+inline int InitRequest::_internal_package_hash_size() const {
+  return _impl_.package_hash_.size();
+}
+inline int InitRequest::package_hash_size() const {
+  return _internal_package_hash_size();
+}
+inline void InitRequest::clear_package_hash() {
+  _impl_.package_hash_.Clear();
+}
+inline std::string* InitRequest::add_package_hash() {
+  std::string* _s = _internal_add_package_hash();
+  // @@protoc_insertion_point(field_add_mutable:InitRequest.package_hash)
+  return _s;
+}
+inline const std::string& InitRequest::_internal_package_hash(int index) const {
+  return _impl_.package_hash_.Get(index);
+}
+inline const std::string& InitRequest::package_hash(int index) const {
+  // @@protoc_insertion_point(field_get:InitRequest.package_hash)
+  return _internal_package_hash(index);
+}
+inline std::string* InitRequest::mutable_package_hash(int index) {
+  // @@protoc_insertion_point(field_mutable:InitRequest.package_hash)
+  return _impl_.package_hash_.Mutable(index);
+}
+inline void InitRequest::set_package_hash(int index, const std::string& value) {
+  _impl_.package_hash_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:InitRequest.package_hash)
+}
+inline void InitRequest::set_package_hash(int index, std::string&& value) {
+  _impl_.package_hash_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:InitRequest.package_hash)
+}
+inline void InitRequest::set_package_hash(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.package_hash_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:InitRequest.package_hash)
+}
+inline void InitRequest::set_package_hash(int index, const void* value, size_t size) {
+  _impl_.package_hash_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:InitRequest.package_hash)
+}
+inline std::string* InitRequest::_internal_add_package_hash() {
+  return _impl_.package_hash_.Add();
+}
+inline void InitRequest::add_package_hash(const std::string& value) {
+  _impl_.package_hash_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:InitRequest.package_hash)
+}
+inline void InitRequest::add_package_hash(std::string&& value) {
+  _impl_.package_hash_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:InitRequest.package_hash)
+}
+inline void InitRequest::add_package_hash(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.package_hash_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:InitRequest.package_hash)
+}
+inline void InitRequest::add_package_hash(const void* value, size_t size) {
+  _impl_.package_hash_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:InitRequest.package_hash)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+InitRequest::package_hash() const {
+  // @@protoc_insertion_point(field_list:InitRequest.package_hash)
+  return _impl_.package_hash_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+InitRequest::mutable_package_hash() {
+  // @@protoc_insertion_point(field_mutable_list:InitRequest.package_hash)
+  return &_impl_.package_hash_;
+}
+
+// -------------------------------------------------------------------
+
+// InitResponse
+
+// -------------------------------------------------------------------
+
+// CompileRequest
+
+// .Function function = 2;
+inline bool CompileRequest::_internal_has_function() const {
+  return this != internal_default_instance() && _impl_.function_ != nullptr;
+}
+inline bool CompileRequest::has_function() const {
+  return _internal_has_function();
+}
+inline void CompileRequest::clear_function() {
+  if (GetArenaForAllocation() == nullptr && _impl_.function_ != nullptr) {
+    delete _impl_.function_;
+  }
+  _impl_.function_ = nullptr;
+}
+inline const ::Function& CompileRequest::_internal_function() const {
+  const ::Function* p = _impl_.function_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Function&>(
+      ::_Function_default_instance_);
+}
+inline const ::Function& CompileRequest::function() const {
+  // @@protoc_insertion_point(field_get:CompileRequest.function)
+  return _internal_function();
+}
+inline void CompileRequest::unsafe_arena_set_allocated_function(
+    ::Function* function) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_);
+  }
+  _impl_.function_ = function;
+  if (function) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CompileRequest.function)
+}
+inline ::Function* CompileRequest::release_function() {
+  
+  ::Function* temp = _impl_.function_;
+  _impl_.function_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Function* CompileRequest::unsafe_arena_release_function() {
+  // @@protoc_insertion_point(field_release:CompileRequest.function)
+  
+  ::Function* temp = _impl_.function_;
+  _impl_.function_ = nullptr;
+  return temp;
+}
+inline ::Function* CompileRequest::_internal_mutable_function() {
+  
+  if (_impl_.function_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Function>(GetArenaForAllocation());
+    _impl_.function_ = p;
+  }
+  return _impl_.function_;
+}
+inline ::Function* CompileRequest::mutable_function() {
+  ::Function* _msg = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:CompileRequest.function)
+  return _msg;
+}
+inline void CompileRequest::set_allocated_function(::Function* function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.function_;
+  }
+  if (function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(function);
+    if (message_arena != submessage_arena) {
+      function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, function, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.function_ = function;
+  // @@protoc_insertion_point(field_set_allocated:CompileRequest.function)
+}
+
+// optional .Tier tier = 4;
+inline bool CompileRequest::_internal_has_tier() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CompileRequest::has_tier() const {
+  return _internal_has_tier();
+}
+inline void CompileRequest::clear_tier() {
+  _impl_.tier_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::Tier CompileRequest::_internal_tier() const {
+  return static_cast< ::Tier >(_impl_.tier_);
+}
+inline ::Tier CompileRequest::tier() const {
+  // @@protoc_insertion_point(field_get:CompileRequest.tier)
+  return _internal_tier();
+}
+inline void CompileRequest::_internal_set_tier(::Tier value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.tier_ = value;
+}
+inline void CompileRequest::set_tier(::Tier value) {
+  _internal_set_tier(value);
+  // @@protoc_insertion_point(field_set:CompileRequest.tier)
+}
+
+// optional int32 optimization_level = 5;
+inline bool CompileRequest::_internal_has_optimization_level() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool CompileRequest::has_optimization_level() const {
+  return _internal_has_optimization_level();
+}
+inline void CompileRequest::clear_optimization_level() {
+  _impl_.optimization_level_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t CompileRequest::_internal_optimization_level() const {
+  return _impl_.optimization_level_;
+}
+inline int32_t CompileRequest::optimization_level() const {
+  // @@protoc_insertion_point(field_get:CompileRequest.optimization_level)
+  return _internal_optimization_level();
+}
+inline void CompileRequest::_internal_set_optimization_level(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.optimization_level_ = value;
+}
+inline void CompileRequest::set_optimization_level(int32_t value) {
+  _internal_set_optimization_level(value);
+  // @@protoc_insertion_point(field_set:CompileRequest.optimization_level)
+}
+
+// optional .Context context = 6;
+inline bool CompileRequest::_internal_has_context() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.context_ != nullptr);
+  return value;
+}
+inline bool CompileRequest::has_context() const {
+  return _internal_has_context();
+}
+inline void CompileRequest::clear_context() {
+  if (_impl_.context_ != nullptr) _impl_.context_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::Context& CompileRequest::_internal_context() const {
+  const ::Context* p = _impl_.context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Context&>(
+      ::_Context_default_instance_);
+}
+inline const ::Context& CompileRequest::context() const {
+  // @@protoc_insertion_point(field_get:CompileRequest.context)
+  return _internal_context();
+}
+inline void CompileRequest::unsafe_arena_set_allocated_context(
+    ::Context* context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.context_);
+  }
+  _impl_.context_ = context;
+  if (context) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CompileRequest.context)
+}
+inline ::Context* CompileRequest::release_context() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::Context* temp = _impl_.context_;
+  _impl_.context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Context* CompileRequest::unsafe_arena_release_context() {
+  // @@protoc_insertion_point(field_release:CompileRequest.context)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::Context* temp = _impl_.context_;
+  _impl_.context_ = nullptr;
+  return temp;
+}
+inline ::Context* CompileRequest::_internal_mutable_context() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Context>(GetArenaForAllocation());
+    _impl_.context_ = p;
+  }
+  return _impl_.context_;
+}
+inline ::Context* CompileRequest::mutable_context() {
+  ::Context* _msg = _internal_mutable_context();
+  // @@protoc_insertion_point(field_mutable:CompileRequest.context)
+  return _msg;
+}
+inline void CompileRequest::set_allocated_context(::Context* context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.context_;
+  }
+  if (context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(context);
+    if (message_arena != submessage_arena) {
+      context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, context, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.context_ = context;
+  // @@protoc_insertion_point(field_set_allocated:CompileRequest.context)
+}
+
+// optional .Environment environment = 7;
+inline bool CompileRequest::_internal_has_environment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.environment_ != nullptr);
+  return value;
+}
+inline bool CompileRequest::has_environment() const {
+  return _internal_has_environment();
+}
+inline void CompileRequest::clear_environment() {
+  if (_impl_.environment_ != nullptr) _impl_.environment_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::Environment& CompileRequest::_internal_environment() const {
+  const ::Environment* p = _impl_.environment_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Environment&>(
+      ::_Environment_default_instance_);
+}
+inline const ::Environment& CompileRequest::environment() const {
+  // @@protoc_insertion_point(field_get:CompileRequest.environment)
+  return _internal_environment();
+}
+inline void CompileRequest::unsafe_arena_set_allocated_environment(
+    ::Environment* environment) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.environment_);
+  }
+  _impl_.environment_ = environment;
+  if (environment) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CompileRequest.environment)
+}
+inline ::Environment* CompileRequest::release_environment() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::Environment* temp = _impl_.environment_;
+  _impl_.environment_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Environment* CompileRequest::unsafe_arena_release_environment() {
+  // @@protoc_insertion_point(field_release:CompileRequest.environment)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::Environment* temp = _impl_.environment_;
+  _impl_.environment_ = nullptr;
+  return temp;
+}
+inline ::Environment* CompileRequest::_internal_mutable_environment() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.environment_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Environment>(GetArenaForAllocation());
+    _impl_.environment_ = p;
+  }
+  return _impl_.environment_;
+}
+inline ::Environment* CompileRequest::mutable_environment() {
+  ::Environment* _msg = _internal_mutable_environment();
+  // @@protoc_insertion_point(field_mutable:CompileRequest.environment)
+  return _msg;
+}
+inline void CompileRequest::set_allocated_environment(::Environment* environment) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.environment_;
+  }
+  if (environment) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(environment);
+    if (message_arena != submessage_arena) {
+      environment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, environment, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.environment_ = environment;
+  // @@protoc_insertion_point(field_set_allocated:CompileRequest.environment)
+}
+
+// -------------------------------------------------------------------
+
+// CompileResponse
+
+// bytes hash = 1;
+inline void CompileResponse::clear_hash() {
+  _impl_.hash_.ClearToEmpty();
+}
+inline const std::string& CompileResponse::hash() const {
+  // @@protoc_insertion_point(field_get:CompileResponse.hash)
+  return _internal_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompileResponse::set_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CompileResponse.hash)
+}
+inline std::string* CompileResponse::mutable_hash() {
+  std::string* _s = _internal_mutable_hash();
+  // @@protoc_insertion_point(field_mutable:CompileResponse.hash)
+  return _s;
+}
+inline const std::string& CompileResponse::_internal_hash() const {
+  return _impl_.hash_.Get();
+}
+inline void CompileResponse::_internal_set_hash(const std::string& value) {
+  
+  _impl_.hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CompileResponse::_internal_mutable_hash() {
+  
+  return _impl_.hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CompileResponse::release_hash() {
+  // @@protoc_insertion_point(field_release:CompileResponse.hash)
+  return _impl_.hash_.Release();
+}
+inline void CompileResponse::set_allocated_hash(std::string* hash) {
+  if (hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CompileResponse.hash)
+}
+
+// .Tier tier = 2;
+inline void CompileResponse::clear_tier() {
+  _impl_.tier_ = 0;
+}
+inline ::Tier CompileResponse::_internal_tier() const {
+  return static_cast< ::Tier >(_impl_.tier_);
+}
+inline ::Tier CompileResponse::tier() const {
+  // @@protoc_insertion_point(field_get:CompileResponse.tier)
+  return _internal_tier();
+}
+inline void CompileResponse::_internal_set_tier(::Tier value) {
+  
+  _impl_.tier_ = value;
+}
+inline void CompileResponse::set_tier(::Tier value) {
+  _internal_set_tier(value);
+  // @@protoc_insertion_point(field_set:CompileResponse.tier)
+}
+
+// optional bytes code = 3;
+inline bool CompileResponse::_internal_has_code() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CompileResponse::has_code() const {
+  return _internal_has_code();
+}
+inline void CompileResponse::clear_code() {
+  _impl_.code_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CompileResponse::code() const {
+  // @@protoc_insertion_point(field_get:CompileResponse.code)
+  return _internal_code();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompileResponse::set_code(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.code_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CompileResponse.code)
+}
+inline std::string* CompileResponse::mutable_code() {
+  std::string* _s = _internal_mutable_code();
+  // @@protoc_insertion_point(field_mutable:CompileResponse.code)
+  return _s;
+}
+inline const std::string& CompileResponse::_internal_code() const {
+  return _impl_.code_.Get();
+}
+inline void CompileResponse::_internal_set_code(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.code_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CompileResponse::_internal_mutable_code() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.code_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CompileResponse::release_code() {
+  // @@protoc_insertion_point(field_release:CompileResponse.code)
+  if (!_internal_has_code()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.code_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.code_.IsDefault()) {
+    _impl_.code_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CompileResponse::set_allocated_code(std::string* code) {
+  if (code != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.code_.SetAllocated(code, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.code_.IsDefault()) {
+    _impl_.code_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CompileResponse.code)
+}
+
+// optional bytes constant_pool = 4;
+inline bool CompileResponse::_internal_has_constant_pool() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CompileResponse::has_constant_pool() const {
+  return _internal_has_constant_pool();
+}
+inline void CompileResponse::clear_constant_pool() {
+  _impl_.constant_pool_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& CompileResponse::constant_pool() const {
+  // @@protoc_insertion_point(field_get:CompileResponse.constant_pool)
+  return _internal_constant_pool();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompileResponse::set_constant_pool(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.constant_pool_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CompileResponse.constant_pool)
+}
+inline std::string* CompileResponse::mutable_constant_pool() {
+  std::string* _s = _internal_mutable_constant_pool();
+  // @@protoc_insertion_point(field_mutable:CompileResponse.constant_pool)
+  return _s;
+}
+inline const std::string& CompileResponse::_internal_constant_pool() const {
+  return _impl_.constant_pool_.Get();
+}
+inline void CompileResponse::_internal_set_constant_pool(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.constant_pool_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CompileResponse::_internal_mutable_constant_pool() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.constant_pool_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CompileResponse::release_constant_pool() {
+  // @@protoc_insertion_point(field_release:CompileResponse.constant_pool)
+  if (!_internal_has_constant_pool()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.constant_pool_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.constant_pool_.IsDefault()) {
+    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CompileResponse::set_allocated_constant_pool(std::string* constant_pool) {
+  if (constant_pool != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.constant_pool_.SetAllocated(constant_pool, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.constant_pool_.IsDefault()) {
+    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CompileResponse.constant_pool)
+}
+
+// -------------------------------------------------------------------
+
+// Function
+
+// bytes package_hash = 1;
+inline void Function::clear_package_hash() {
+  _impl_.package_hash_.ClearToEmpty();
+}
+inline const std::string& Function::package_hash() const {
+  // @@protoc_insertion_point(field_get:Function.package_hash)
+  return _internal_package_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Function::set_package_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.package_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Function.package_hash)
+}
+inline std::string* Function::mutable_package_hash() {
+  std::string* _s = _internal_mutable_package_hash();
+  // @@protoc_insertion_point(field_mutable:Function.package_hash)
+  return _s;
+}
+inline const std::string& Function::_internal_package_hash() const {
+  return _impl_.package_hash_.Get();
+}
+inline void Function::_internal_set_package_hash(const std::string& value) {
+  
+  _impl_.package_hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Function::_internal_mutable_package_hash() {
+  
+  return _impl_.package_hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Function::release_package_hash() {
+  // @@protoc_insertion_point(field_release:Function.package_hash)
+  return _impl_.package_hash_.Release();
+}
+inline void Function::set_allocated_package_hash(std::string* package_hash) {
+  if (package_hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.package_hash_.SetAllocated(package_hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.package_hash_.IsDefault()) {
+    _impl_.package_hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Function.package_hash)
+}
+
+// string name = 2;
+inline void Function::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Function::name() const {
+  // @@protoc_insertion_point(field_get:Function.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Function::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Function.name)
+}
+inline std::string* Function::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:Function.name)
+  return _s;
+}
+inline const std::string& Function::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Function::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Function::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Function::release_name() {
+  // @@protoc_insertion_point(field_release:Function.name)
+  return _impl_.name_.Release();
+}
+inline void Function::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Function.name)
+}
+
+// bytes hash = 3;
+inline void Function::clear_hash() {
+  _impl_.hash_.ClearToEmpty();
+}
+inline const std::string& Function::hash() const {
+  // @@protoc_insertion_point(field_get:Function.hash)
+  return _internal_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Function::set_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Function.hash)
+}
+inline std::string* Function::mutable_hash() {
+  std::string* _s = _internal_mutable_hash();
+  // @@protoc_insertion_point(field_mutable:Function.hash)
+  return _s;
+}
+inline const std::string& Function::_internal_hash() const {
+  return _impl_.hash_.Get();
+}
+inline void Function::_internal_set_hash(const std::string& value) {
+  
+  _impl_.hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Function::_internal_mutable_hash() {
+  
+  return _impl_.hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Function::release_hash() {
+  // @@protoc_insertion_point(field_release:Function.hash)
+  return _impl_.hash_.Release();
+}
+inline void Function::set_allocated_hash(std::string* hash) {
+  if (hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Function.hash)
+}
+
+// optional bytes body = 4;
+inline bool Function::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Function::has_body() const {
+  return _internal_has_body();
+}
+inline void Function::clear_body() {
+  _impl_.body_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Function::body() const {
+  // @@protoc_insertion_point(field_get:Function.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Function::set_body(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.body_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Function.body)
+}
+inline std::string* Function::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:Function.body)
+  return _s;
+}
+inline const std::string& Function::_internal_body() const {
+  return _impl_.body_.Get();
+}
+inline void Function::_internal_set_body(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.body_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Function::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.body_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Function::release_body() {
+  // @@protoc_insertion_point(field_release:Function.body)
+  if (!_internal_has_body()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.body_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Function::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Function.body)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionRequest
+
+// bytes hash = 1;
+inline void FunctionRequest::clear_hash() {
+  _impl_.hash_.ClearToEmpty();
+}
+inline const std::string& FunctionRequest::hash() const {
+  // @@protoc_insertion_point(field_get:FunctionRequest.hash)
+  return _internal_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FunctionRequest::set_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:FunctionRequest.hash)
+}
+inline std::string* FunctionRequest::mutable_hash() {
+  std::string* _s = _internal_mutable_hash();
+  // @@protoc_insertion_point(field_mutable:FunctionRequest.hash)
+  return _s;
+}
+inline const std::string& FunctionRequest::_internal_hash() const {
+  return _impl_.hash_.Get();
+}
+inline void FunctionRequest::_internal_set_hash(const std::string& value) {
+  
+  _impl_.hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FunctionRequest::_internal_mutable_hash() {
+  
+  return _impl_.hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FunctionRequest::release_hash() {
+  // @@protoc_insertion_point(field_release:FunctionRequest.hash)
+  return _impl_.hash_.Release();
+}
+inline void FunctionRequest::set_allocated_hash(std::string* hash) {
+  if (hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:FunctionRequest.hash)
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// Environment
+
+// map<string, bytes> values = 1;
+inline int Environment::_internal_values_size() const {
+  return _impl_.values_.size();
+}
+inline int Environment::values_size() const {
+  return _internal_values_size();
+}
+inline void Environment::clear_values() {
+  _impl_.values_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+Environment::_internal_values() const {
+  return _impl_.values_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+Environment::values() const {
+  // @@protoc_insertion_point(field_map:Environment.values)
+  return _internal_values();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+Environment::_internal_mutable_values() {
+  return _impl_.values_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+Environment::mutable_values() {
+  // @@protoc_insertion_point(field_mutable_map:Environment.values)
+  return _internal_mutable_values();
+}
+
+// -------------------------------------------------------------------
+
+// ValueRequest
+
+// repeated bytes hash = 1;
+inline int ValueRequest::_internal_hash_size() const {
+  return _impl_.hash_.size();
+}
+inline int ValueRequest::hash_size() const {
+  return _internal_hash_size();
+}
+inline void ValueRequest::clear_hash() {
+  _impl_.hash_.Clear();
+}
+inline std::string* ValueRequest::add_hash() {
+  std::string* _s = _internal_add_hash();
+  // @@protoc_insertion_point(field_add_mutable:ValueRequest.hash)
+  return _s;
+}
+inline const std::string& ValueRequest::_internal_hash(int index) const {
+  return _impl_.hash_.Get(index);
+}
+inline const std::string& ValueRequest::hash(int index) const {
+  // @@protoc_insertion_point(field_get:ValueRequest.hash)
+  return _internal_hash(index);
+}
+inline std::string* ValueRequest::mutable_hash(int index) {
+  // @@protoc_insertion_point(field_mutable:ValueRequest.hash)
+  return _impl_.hash_.Mutable(index);
+}
+inline void ValueRequest::set_hash(int index, const std::string& value) {
+  _impl_.hash_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:ValueRequest.hash)
+}
+inline void ValueRequest::set_hash(int index, std::string&& value) {
+  _impl_.hash_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:ValueRequest.hash)
+}
+inline void ValueRequest::set_hash(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.hash_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:ValueRequest.hash)
+}
+inline void ValueRequest::set_hash(int index, const void* value, size_t size) {
+  _impl_.hash_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:ValueRequest.hash)
+}
+inline std::string* ValueRequest::_internal_add_hash() {
+  return _impl_.hash_.Add();
+}
+inline void ValueRequest::add_hash(const std::string& value) {
+  _impl_.hash_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:ValueRequest.hash)
+}
+inline void ValueRequest::add_hash(std::string&& value) {
+  _impl_.hash_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:ValueRequest.hash)
+}
+inline void ValueRequest::add_hash(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.hash_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:ValueRequest.hash)
+}
+inline void ValueRequest::add_hash(const void* value, size_t size) {
+  _impl_.hash_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:ValueRequest.hash)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ValueRequest::hash() const {
+  // @@protoc_insertion_point(field_list:ValueRequest.hash)
+  return _impl_.hash_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ValueRequest::mutable_hash() {
+  // @@protoc_insertion_point(field_mutable_list:ValueRequest.hash)
+  return &_impl_.hash_;
+}
+
+// -------------------------------------------------------------------
+
+// Value
+
+// bytes hash = 1;
+inline void Value::clear_hash() {
+  _impl_.hash_.ClearToEmpty();
+}
+inline const std::string& Value::hash() const {
+  // @@protoc_insertion_point(field_get:Value.hash)
+  return _internal_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Value::set_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Value.hash)
+}
+inline std::string* Value::mutable_hash() {
+  std::string* _s = _internal_mutable_hash();
+  // @@protoc_insertion_point(field_mutable:Value.hash)
+  return _s;
+}
+inline const std::string& Value::_internal_hash() const {
+  return _impl_.hash_.Get();
+}
+inline void Value::_internal_set_hash(const std::string& value) {
+  
+  _impl_.hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Value::_internal_mutable_hash() {
+  
+  return _impl_.hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Value::release_hash() {
+  // @@protoc_insertion_point(field_release:Value.hash)
+  return _impl_.hash_.Release();
+}
+inline void Value::set_allocated_hash(std::string* hash) {
+  if (hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Value.hash)
+}
+
+// bytes value = 2;
+inline void Value::clear_value() {
+  _impl_.value_.ClearToEmpty();
+}
+inline const std::string& Value::value() const {
+  // @@protoc_insertion_point(field_get:Value.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Value::set_value(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Value.value)
+}
+inline std::string* Value::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:Value.value)
+  return _s;
+}
+inline const std::string& Value::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void Value::_internal_set_value(const std::string& value) {
+  
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Value::_internal_mutable_value() {
+  
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Value::release_value() {
+  // @@protoc_insertion_point(field_release:Value.value)
+  return _impl_.value_.Release();
+}
+inline void Value::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// Values
+
+// repeated .Value values = 1;
+inline int Values::_internal_values_size() const {
+  return _impl_.values_.size();
+}
+inline int Values::values_size() const {
+  return _internal_values_size();
+}
+inline void Values::clear_values() {
+  _impl_.values_.Clear();
+}
+inline ::Value* Values::mutable_values(int index) {
+  // @@protoc_insertion_point(field_mutable:Values.values)
+  return _impl_.values_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >*
+Values::mutable_values() {
+  // @@protoc_insertion_point(field_mutable_list:Values.values)
+  return &_impl_.values_;
+}
+inline const ::Value& Values::_internal_values(int index) const {
+  return _impl_.values_.Get(index);
+}
+inline const ::Value& Values::values(int index) const {
+  // @@protoc_insertion_point(field_get:Values.values)
+  return _internal_values(index);
+}
+inline ::Value* Values::_internal_add_values() {
+  return _impl_.values_.Add();
+}
+inline ::Value* Values::add_values() {
+  ::Value* _add = _internal_add_values();
+  // @@protoc_insertion_point(field_add:Values.values)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >&
+Values::values() const {
+  // @@protoc_insertion_point(field_list:Values.values)
+  return _impl_.values_;
+}
+
+// -------------------------------------------------------------------
+
+// Empty
+
+// -------------------------------------------------------------------
+
+// CallContext
+
+// bool args_statically_matched = 1;
+inline void CallContext::clear_args_statically_matched() {
+  _impl_.args_statically_matched_ = false;
+}
+inline bool CallContext::_internal_args_statically_matched() const {
+  return _impl_.args_statically_matched_;
+}
+inline bool CallContext::args_statically_matched() const {
+  // @@protoc_insertion_point(field_get:CallContext.args_statically_matched)
+  return _internal_args_statically_matched();
+}
+inline void CallContext::_internal_set_args_statically_matched(bool value) {
+  
+  _impl_.args_statically_matched_ = value;
+}
+inline void CallContext::set_args_statically_matched(bool value) {
+  _internal_set_args_statically_matched(value);
+  // @@protoc_insertion_point(field_set:CallContext.args_statically_matched)
+}
+
+// bool correct_number_of_args = 2;
+inline void CallContext::clear_correct_number_of_args() {
+  _impl_.correct_number_of_args_ = false;
+}
+inline bool CallContext::_internal_correct_number_of_args() const {
+  return _impl_.correct_number_of_args_;
+}
+inline bool CallContext::correct_number_of_args() const {
+  // @@protoc_insertion_point(field_get:CallContext.correct_number_of_args)
+  return _internal_correct_number_of_args();
+}
+inline void CallContext::_internal_set_correct_number_of_args(bool value) {
+  
+  _impl_.correct_number_of_args_ = value;
+}
+inline void CallContext::set_correct_number_of_args(bool value) {
+  _internal_set_correct_number_of_args(value);
+  // @@protoc_insertion_point(field_set:CallContext.correct_number_of_args)
+}
+
+// bool correct_order_of_args = 3;
+inline void CallContext::clear_correct_order_of_args() {
+  _impl_.correct_order_of_args_ = false;
+}
+inline bool CallContext::_internal_correct_order_of_args() const {
+  return _impl_.correct_order_of_args_;
+}
+inline bool CallContext::correct_order_of_args() const {
+  // @@protoc_insertion_point(field_get:CallContext.correct_order_of_args)
+  return _internal_correct_order_of_args();
+}
+inline void CallContext::_internal_set_correct_order_of_args(bool value) {
+  
+  _impl_.correct_order_of_args_ = value;
+}
+inline void CallContext::set_correct_order_of_args(bool value) {
+  _internal_set_correct_order_of_args(value);
+  // @@protoc_insertion_point(field_set:CallContext.correct_order_of_args)
+}
+
+// bool no_missing_args = 4;
+inline void CallContext::clear_no_missing_args() {
+  _impl_.no_missing_args_ = false;
+}
+inline bool CallContext::_internal_no_missing_args() const {
+  return _impl_.no_missing_args_;
+}
+inline bool CallContext::no_missing_args() const {
+  // @@protoc_insertion_point(field_get:CallContext.no_missing_args)
+  return _internal_no_missing_args();
+}
+inline void CallContext::_internal_set_no_missing_args(bool value) {
+  
+  _impl_.no_missing_args_ = value;
+}
+inline void CallContext::set_no_missing_args(bool value) {
+  _internal_set_no_missing_args(value);
+  // @@protoc_insertion_point(field_set:CallContext.no_missing_args)
+}
+
+// -------------------------------------------------------------------
+
+// ArgumentContext
+
+// bool eager = 1;
+inline void ArgumentContext::clear_eager() {
+  _impl_.eager_ = false;
+}
+inline bool ArgumentContext::_internal_eager() const {
+  return _impl_.eager_;
+}
+inline bool ArgumentContext::eager() const {
+  // @@protoc_insertion_point(field_get:ArgumentContext.eager)
+  return _internal_eager();
+}
+inline void ArgumentContext::_internal_set_eager(bool value) {
+  
+  _impl_.eager_ = value;
+}
+inline void ArgumentContext::set_eager(bool value) {
+  _internal_set_eager(value);
+  // @@protoc_insertion_point(field_set:ArgumentContext.eager)
+}
+
+// bool reflection = 2;
+inline void ArgumentContext::clear_reflection() {
+  _impl_.reflection_ = false;
+}
+inline bool ArgumentContext::_internal_reflection() const {
+  return _impl_.reflection_;
+}
+inline bool ArgumentContext::reflection() const {
+  // @@protoc_insertion_point(field_get:ArgumentContext.reflection)
+  return _internal_reflection();
+}
+inline void ArgumentContext::_internal_set_reflection(bool value) {
+  
+  _impl_.reflection_ = value;
+}
+inline void ArgumentContext::set_reflection(bool value) {
+  _internal_set_reflection(value);
+  // @@protoc_insertion_point(field_set:ArgumentContext.reflection)
+}
+
+// bool object = 3;
+inline void ArgumentContext::clear_object() {
+  _impl_.object_ = false;
+}
+inline bool ArgumentContext::_internal_object() const {
+  return _impl_.object_;
+}
+inline bool ArgumentContext::object() const {
+  // @@protoc_insertion_point(field_get:ArgumentContext.object)
+  return _internal_object();
+}
+inline void ArgumentContext::_internal_set_object(bool value) {
+  
+  _impl_.object_ = value;
+}
+inline void ArgumentContext::set_object(bool value) {
+  _internal_set_object(value);
+  // @@protoc_insertion_point(field_set:ArgumentContext.object)
+}
+
+// optional .Type type = 4;
+inline bool ArgumentContext::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ArgumentContext::has_type() const {
+  return _internal_has_type();
+}
+inline void ArgumentContext::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::Type ArgumentContext::_internal_type() const {
+  return static_cast< ::Type >(_impl_.type_);
+}
+inline ::Type ArgumentContext::type() const {
+  // @@protoc_insertion_point(field_get:ArgumentContext.type)
+  return _internal_type();
+}
+inline void ArgumentContext::_internal_set_type(::Type value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.type_ = value;
+}
+inline void ArgumentContext::set_type(::Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:ArgumentContext.type)
+}
+
+// -------------------------------------------------------------------
+
+// Context
+
+// .CallContext call_context = 1;
+inline bool Context::_internal_has_call_context() const {
+  return this != internal_default_instance() && _impl_.call_context_ != nullptr;
+}
+inline bool Context::has_call_context() const {
+  return _internal_has_call_context();
+}
+inline void Context::clear_call_context() {
+  if (GetArenaForAllocation() == nullptr && _impl_.call_context_ != nullptr) {
+    delete _impl_.call_context_;
+  }
+  _impl_.call_context_ = nullptr;
+}
+inline const ::CallContext& Context::_internal_call_context() const {
+  const ::CallContext* p = _impl_.call_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::CallContext&>(
+      ::_CallContext_default_instance_);
+}
+inline const ::CallContext& Context::call_context() const {
+  // @@protoc_insertion_point(field_get:Context.call_context)
+  return _internal_call_context();
+}
+inline void Context::unsafe_arena_set_allocated_call_context(
+    ::CallContext* call_context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.call_context_);
+  }
+  _impl_.call_context_ = call_context;
+  if (call_context) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Context.call_context)
+}
+inline ::CallContext* Context::release_call_context() {
+  
+  ::CallContext* temp = _impl_.call_context_;
+  _impl_.call_context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::CallContext* Context::unsafe_arena_release_call_context() {
+  // @@protoc_insertion_point(field_release:Context.call_context)
+  
+  ::CallContext* temp = _impl_.call_context_;
+  _impl_.call_context_ = nullptr;
+  return temp;
+}
+inline ::CallContext* Context::_internal_mutable_call_context() {
+  
+  if (_impl_.call_context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::CallContext>(GetArenaForAllocation());
+    _impl_.call_context_ = p;
+  }
+  return _impl_.call_context_;
+}
+inline ::CallContext* Context::mutable_call_context() {
+  ::CallContext* _msg = _internal_mutable_call_context();
+  // @@protoc_insertion_point(field_mutable:Context.call_context)
+  return _msg;
+}
+inline void Context::set_allocated_call_context(::CallContext* call_context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.call_context_;
+  }
+  if (call_context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(call_context);
+    if (message_arena != submessage_arena) {
+      call_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, call_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.call_context_ = call_context;
+  // @@protoc_insertion_point(field_set_allocated:Context.call_context)
+}
+
+// repeated .ArgumentContext argument_context = 2;
+inline int Context::_internal_argument_context_size() const {
+  return _impl_.argument_context_.size();
+}
+inline int Context::argument_context_size() const {
+  return _internal_argument_context_size();
+}
+inline void Context::clear_argument_context() {
+  _impl_.argument_context_.Clear();
+}
+inline ::ArgumentContext* Context::mutable_argument_context(int index) {
+  // @@protoc_insertion_point(field_mutable:Context.argument_context)
+  return _impl_.argument_context_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >*
+Context::mutable_argument_context() {
+  // @@protoc_insertion_point(field_mutable_list:Context.argument_context)
+  return &_impl_.argument_context_;
+}
+inline const ::ArgumentContext& Context::_internal_argument_context(int index) const {
+  return _impl_.argument_context_.Get(index);
+}
+inline const ::ArgumentContext& Context::argument_context(int index) const {
+  // @@protoc_insertion_point(field_get:Context.argument_context)
+  return _internal_argument_context(index);
+}
+inline ::ArgumentContext* Context::_internal_add_argument_context() {
+  return _impl_.argument_context_.Add();
+}
+inline ::ArgumentContext* Context::add_argument_context() {
+  ::ArgumentContext* _add = _internal_add_argument_context();
+  // @@protoc_insertion_point(field_add:Context.argument_context)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >&
+Context::argument_context() const {
+  // @@protoc_insertion_point(field_list:Context.argument_context)
+  return _impl_.argument_context_;
+}
+
+// -------------------------------------------------------------------
+
+// ContextRequest
+
+// .Function function = 1;
+inline bool ContextRequest::_internal_has_function() const {
+  return this != internal_default_instance() && _impl_.function_ != nullptr;
+}
+inline bool ContextRequest::has_function() const {
+  return _internal_has_function();
+}
+inline void ContextRequest::clear_function() {
+  if (GetArenaForAllocation() == nullptr && _impl_.function_ != nullptr) {
+    delete _impl_.function_;
+  }
+  _impl_.function_ = nullptr;
+}
+inline const ::Function& ContextRequest::_internal_function() const {
+  const ::Function* p = _impl_.function_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Function&>(
+      ::_Function_default_instance_);
+}
+inline const ::Function& ContextRequest::function() const {
+  // @@protoc_insertion_point(field_get:ContextRequest.function)
+  return _internal_function();
+}
+inline void ContextRequest::unsafe_arena_set_allocated_function(
+    ::Function* function) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_);
+  }
+  _impl_.function_ = function;
+  if (function) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ContextRequest.function)
+}
+inline ::Function* ContextRequest::release_function() {
+  
+  ::Function* temp = _impl_.function_;
+  _impl_.function_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Function* ContextRequest::unsafe_arena_release_function() {
+  // @@protoc_insertion_point(field_release:ContextRequest.function)
+  
+  ::Function* temp = _impl_.function_;
+  _impl_.function_ = nullptr;
+  return temp;
+}
+inline ::Function* ContextRequest::_internal_mutable_function() {
+  
+  if (_impl_.function_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Function>(GetArenaForAllocation());
+    _impl_.function_ = p;
+  }
+  return _impl_.function_;
+}
+inline ::Function* ContextRequest::mutable_function() {
+  ::Function* _msg = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:ContextRequest.function)
+  return _msg;
+}
+inline void ContextRequest::set_allocated_function(::Function* function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.function_;
+  }
+  if (function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(function);
+    if (message_arena != submessage_arena) {
+      function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, function, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.function_ = function;
+  // @@protoc_insertion_point(field_set_allocated:ContextRequest.function)
+}
+
+// -------------------------------------------------------------------
+
+// TestFeedback
+
+// .TestLattice test_lattice = 1;
+inline void TestFeedback::clear_test_lattice() {
+  _impl_.test_lattice_ = 0;
+}
+inline ::TestLattice TestFeedback::_internal_test_lattice() const {
+  return static_cast< ::TestLattice >(_impl_.test_lattice_);
+}
+inline ::TestLattice TestFeedback::test_lattice() const {
+  // @@protoc_insertion_point(field_get:TestFeedback.test_lattice)
+  return _internal_test_lattice();
+}
+inline void TestFeedback::_internal_set_test_lattice(::TestLattice value) {
+  
+  _impl_.test_lattice_ = value;
+}
+inline void TestFeedback::set_test_lattice(::TestLattice value) {
+  _internal_set_test_lattice(value);
+  // @@protoc_insertion_point(field_set:TestFeedback.test_lattice)
+}
+
+// -------------------------------------------------------------------
+
+// CallFeedback
+
+// int64 n_calls = 1;
+inline void CallFeedback::clear_n_calls() {
+  _impl_.n_calls_ = int64_t{0};
+}
+inline int64_t CallFeedback::_internal_n_calls() const {
+  return _impl_.n_calls_;
+}
+inline int64_t CallFeedback::n_calls() const {
+  // @@protoc_insertion_point(field_get:CallFeedback.n_calls)
+  return _internal_n_calls();
+}
+inline void CallFeedback::_internal_set_n_calls(int64_t value) {
+  
+  _impl_.n_calls_ = value;
+}
+inline void CallFeedback::set_n_calls(int64_t value) {
+  _internal_set_n_calls(value);
+  // @@protoc_insertion_point(field_set:CallFeedback.n_calls)
+}
+
+// bytes callee_hash = 2;
+inline void CallFeedback::clear_callee_hash() {
+  _impl_.callee_hash_.ClearToEmpty();
+}
+inline const std::string& CallFeedback::callee_hash() const {
+  // @@protoc_insertion_point(field_get:CallFeedback.callee_hash)
+  return _internal_callee_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CallFeedback::set_callee_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.callee_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:CallFeedback.callee_hash)
+}
+inline std::string* CallFeedback::mutable_callee_hash() {
+  std::string* _s = _internal_mutable_callee_hash();
+  // @@protoc_insertion_point(field_mutable:CallFeedback.callee_hash)
+  return _s;
+}
+inline const std::string& CallFeedback::_internal_callee_hash() const {
+  return _impl_.callee_hash_.Get();
+}
+inline void CallFeedback::_internal_set_callee_hash(const std::string& value) {
+  
+  _impl_.callee_hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CallFeedback::_internal_mutable_callee_hash() {
+  
+  return _impl_.callee_hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CallFeedback::release_callee_hash() {
+  // @@protoc_insertion_point(field_release:CallFeedback.callee_hash)
+  return _impl_.callee_hash_.Release();
+}
+inline void CallFeedback::set_allocated_callee_hash(std::string* callee_hash) {
+  if (callee_hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.callee_hash_.SetAllocated(callee_hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.callee_hash_.IsDefault()) {
+    _impl_.callee_hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:CallFeedback.callee_hash)
+}
+
+// -------------------------------------------------------------------
+
+// ValueFeedback
+
+// bool scalar = 1;
+inline void ValueFeedback::clear_scalar() {
+  _impl_.scalar_ = false;
+}
+inline bool ValueFeedback::_internal_scalar() const {
+  return _impl_.scalar_;
+}
+inline bool ValueFeedback::scalar() const {
+  // @@protoc_insertion_point(field_get:ValueFeedback.scalar)
+  return _internal_scalar();
+}
+inline void ValueFeedback::_internal_set_scalar(bool value) {
+  
+  _impl_.scalar_ = value;
+}
+inline void ValueFeedback::set_scalar(bool value) {
+  _internal_set_scalar(value);
+  // @@protoc_insertion_point(field_set:ValueFeedback.scalar)
+}
+
+// bool object = 2;
+inline void ValueFeedback::clear_object() {
+  _impl_.object_ = false;
+}
+inline bool ValueFeedback::_internal_object() const {
+  return _impl_.object_;
+}
+inline bool ValueFeedback::object() const {
+  // @@protoc_insertion_point(field_get:ValueFeedback.object)
+  return _internal_object();
+}
+inline void ValueFeedback::_internal_set_object(bool value) {
+  
+  _impl_.object_ = value;
+}
+inline void ValueFeedback::set_object(bool value) {
+  _internal_set_object(value);
+  // @@protoc_insertion_point(field_set:ValueFeedback.object)
+}
+
+// bool accessed_attributes = 3;
+inline void ValueFeedback::clear_accessed_attributes() {
+  _impl_.accessed_attributes_ = false;
+}
+inline bool ValueFeedback::_internal_accessed_attributes() const {
+  return _impl_.accessed_attributes_;
+}
+inline bool ValueFeedback::accessed_attributes() const {
+  // @@protoc_insertion_point(field_get:ValueFeedback.accessed_attributes)
+  return _internal_accessed_attributes();
+}
+inline void ValueFeedback::_internal_set_accessed_attributes(bool value) {
+  
+  _impl_.accessed_attributes_ = value;
+}
+inline void ValueFeedback::set_accessed_attributes(bool value) {
+  _internal_set_accessed_attributes(value);
+  // @@protoc_insertion_point(field_set:ValueFeedback.accessed_attributes)
+}
+
+// bool vectorizable = 4;
+inline void ValueFeedback::clear_vectorizable() {
+  _impl_.vectorizable_ = false;
+}
+inline bool ValueFeedback::_internal_vectorizable() const {
+  return _impl_.vectorizable_;
+}
+inline bool ValueFeedback::vectorizable() const {
+  // @@protoc_insertion_point(field_get:ValueFeedback.vectorizable)
+  return _internal_vectorizable();
+}
+inline void ValueFeedback::_internal_set_vectorizable(bool value) {
+  
+  _impl_.vectorizable_ = value;
+}
+inline void ValueFeedback::set_vectorizable(bool value) {
+  _internal_set_vectorizable(value);
+  // @@protoc_insertion_point(field_set:ValueFeedback.vectorizable)
+}
+
+// bool is_promise = 5;
+inline void ValueFeedback::clear_is_promise() {
+  _impl_.is_promise_ = false;
+}
+inline bool ValueFeedback::_internal_is_promise() const {
+  return _impl_.is_promise_;
+}
+inline bool ValueFeedback::is_promise() const {
+  // @@protoc_insertion_point(field_get:ValueFeedback.is_promise)
+  return _internal_is_promise();
+}
+inline void ValueFeedback::_internal_set_is_promise(bool value) {
+  
+  _impl_.is_promise_ = value;
+}
+inline void ValueFeedback::set_is_promise(bool value) {
+  _internal_set_is_promise(value);
+  // @@protoc_insertion_point(field_set:ValueFeedback.is_promise)
+}
+
+// -------------------------------------------------------------------
+
+// TypeFeedback_Feedback
+
+// .TestFeedback test_feedback = 1;
+inline bool TypeFeedback_Feedback::_internal_has_test_feedback() const {
+  return feedback_case() == kTestFeedback;
+}
+inline bool TypeFeedback_Feedback::has_test_feedback() const {
+  return _internal_has_test_feedback();
+}
+inline void TypeFeedback_Feedback::set_has_test_feedback() {
+  _impl_._oneof_case_[0] = kTestFeedback;
+}
+inline void TypeFeedback_Feedback::clear_test_feedback() {
+  if (_internal_has_test_feedback()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.feedback_.test_feedback_;
+    }
+    clear_has_feedback();
+  }
+}
+inline ::TestFeedback* TypeFeedback_Feedback::release_test_feedback() {
+  // @@protoc_insertion_point(field_release:TypeFeedback.Feedback.test_feedback)
+  if (_internal_has_test_feedback()) {
+    clear_has_feedback();
+    ::TestFeedback* temp = _impl_.feedback_.test_feedback_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.feedback_.test_feedback_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::TestFeedback& TypeFeedback_Feedback::_internal_test_feedback() const {
+  return _internal_has_test_feedback()
+      ? *_impl_.feedback_.test_feedback_
+      : reinterpret_cast< ::TestFeedback&>(::_TestFeedback_default_instance_);
+}
+inline const ::TestFeedback& TypeFeedback_Feedback::test_feedback() const {
+  // @@protoc_insertion_point(field_get:TypeFeedback.Feedback.test_feedback)
+  return _internal_test_feedback();
+}
+inline ::TestFeedback* TypeFeedback_Feedback::unsafe_arena_release_test_feedback() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:TypeFeedback.Feedback.test_feedback)
+  if (_internal_has_test_feedback()) {
+    clear_has_feedback();
+    ::TestFeedback* temp = _impl_.feedback_.test_feedback_;
+    _impl_.feedback_.test_feedback_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_test_feedback(::TestFeedback* test_feedback) {
+  clear_feedback();
+  if (test_feedback) {
+    set_has_test_feedback();
+    _impl_.feedback_.test_feedback_ = test_feedback;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:TypeFeedback.Feedback.test_feedback)
+}
+inline ::TestFeedback* TypeFeedback_Feedback::_internal_mutable_test_feedback() {
+  if (!_internal_has_test_feedback()) {
+    clear_feedback();
+    set_has_test_feedback();
+    _impl_.feedback_.test_feedback_ = CreateMaybeMessage< ::TestFeedback >(GetArenaForAllocation());
+  }
+  return _impl_.feedback_.test_feedback_;
+}
+inline ::TestFeedback* TypeFeedback_Feedback::mutable_test_feedback() {
+  ::TestFeedback* _msg = _internal_mutable_test_feedback();
+  // @@protoc_insertion_point(field_mutable:TypeFeedback.Feedback.test_feedback)
+  return _msg;
+}
+
+// .CallFeedback call_feedback = 2;
+inline bool TypeFeedback_Feedback::_internal_has_call_feedback() const {
+  return feedback_case() == kCallFeedback;
+}
+inline bool TypeFeedback_Feedback::has_call_feedback() const {
+  return _internal_has_call_feedback();
+}
+inline void TypeFeedback_Feedback::set_has_call_feedback() {
+  _impl_._oneof_case_[0] = kCallFeedback;
+}
+inline void TypeFeedback_Feedback::clear_call_feedback() {
+  if (_internal_has_call_feedback()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.feedback_.call_feedback_;
+    }
+    clear_has_feedback();
+  }
+}
+inline ::CallFeedback* TypeFeedback_Feedback::release_call_feedback() {
+  // @@protoc_insertion_point(field_release:TypeFeedback.Feedback.call_feedback)
+  if (_internal_has_call_feedback()) {
+    clear_has_feedback();
+    ::CallFeedback* temp = _impl_.feedback_.call_feedback_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.feedback_.call_feedback_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::CallFeedback& TypeFeedback_Feedback::_internal_call_feedback() const {
+  return _internal_has_call_feedback()
+      ? *_impl_.feedback_.call_feedback_
+      : reinterpret_cast< ::CallFeedback&>(::_CallFeedback_default_instance_);
+}
+inline const ::CallFeedback& TypeFeedback_Feedback::call_feedback() const {
+  // @@protoc_insertion_point(field_get:TypeFeedback.Feedback.call_feedback)
+  return _internal_call_feedback();
+}
+inline ::CallFeedback* TypeFeedback_Feedback::unsafe_arena_release_call_feedback() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:TypeFeedback.Feedback.call_feedback)
+  if (_internal_has_call_feedback()) {
+    clear_has_feedback();
+    ::CallFeedback* temp = _impl_.feedback_.call_feedback_;
+    _impl_.feedback_.call_feedback_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_call_feedback(::CallFeedback* call_feedback) {
+  clear_feedback();
+  if (call_feedback) {
+    set_has_call_feedback();
+    _impl_.feedback_.call_feedback_ = call_feedback;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:TypeFeedback.Feedback.call_feedback)
+}
+inline ::CallFeedback* TypeFeedback_Feedback::_internal_mutable_call_feedback() {
+  if (!_internal_has_call_feedback()) {
+    clear_feedback();
+    set_has_call_feedback();
+    _impl_.feedback_.call_feedback_ = CreateMaybeMessage< ::CallFeedback >(GetArenaForAllocation());
+  }
+  return _impl_.feedback_.call_feedback_;
+}
+inline ::CallFeedback* TypeFeedback_Feedback::mutable_call_feedback() {
+  ::CallFeedback* _msg = _internal_mutable_call_feedback();
+  // @@protoc_insertion_point(field_mutable:TypeFeedback.Feedback.call_feedback)
+  return _msg;
+}
+
+// .ValueFeedback value_feedback = 3;
+inline bool TypeFeedback_Feedback::_internal_has_value_feedback() const {
+  return feedback_case() == kValueFeedback;
+}
+inline bool TypeFeedback_Feedback::has_value_feedback() const {
+  return _internal_has_value_feedback();
+}
+inline void TypeFeedback_Feedback::set_has_value_feedback() {
+  _impl_._oneof_case_[0] = kValueFeedback;
+}
+inline void TypeFeedback_Feedback::clear_value_feedback() {
+  if (_internal_has_value_feedback()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.feedback_.value_feedback_;
+    }
+    clear_has_feedback();
+  }
+}
+inline ::ValueFeedback* TypeFeedback_Feedback::release_value_feedback() {
+  // @@protoc_insertion_point(field_release:TypeFeedback.Feedback.value_feedback)
+  if (_internal_has_value_feedback()) {
+    clear_has_feedback();
+    ::ValueFeedback* temp = _impl_.feedback_.value_feedback_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.feedback_.value_feedback_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::ValueFeedback& TypeFeedback_Feedback::_internal_value_feedback() const {
+  return _internal_has_value_feedback()
+      ? *_impl_.feedback_.value_feedback_
+      : reinterpret_cast< ::ValueFeedback&>(::_ValueFeedback_default_instance_);
+}
+inline const ::ValueFeedback& TypeFeedback_Feedback::value_feedback() const {
+  // @@protoc_insertion_point(field_get:TypeFeedback.Feedback.value_feedback)
+  return _internal_value_feedback();
+}
+inline ::ValueFeedback* TypeFeedback_Feedback::unsafe_arena_release_value_feedback() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:TypeFeedback.Feedback.value_feedback)
+  if (_internal_has_value_feedback()) {
+    clear_has_feedback();
+    ::ValueFeedback* temp = _impl_.feedback_.value_feedback_;
+    _impl_.feedback_.value_feedback_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_value_feedback(::ValueFeedback* value_feedback) {
+  clear_feedback();
+  if (value_feedback) {
+    set_has_value_feedback();
+    _impl_.feedback_.value_feedback_ = value_feedback;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:TypeFeedback.Feedback.value_feedback)
+}
+inline ::ValueFeedback* TypeFeedback_Feedback::_internal_mutable_value_feedback() {
+  if (!_internal_has_value_feedback()) {
+    clear_feedback();
+    set_has_value_feedback();
+    _impl_.feedback_.value_feedback_ = CreateMaybeMessage< ::ValueFeedback >(GetArenaForAllocation());
+  }
+  return _impl_.feedback_.value_feedback_;
+}
+inline ::ValueFeedback* TypeFeedback_Feedback::mutable_value_feedback() {
+  ::ValueFeedback* _msg = _internal_mutable_value_feedback();
+  // @@protoc_insertion_point(field_mutable:TypeFeedback.Feedback.value_feedback)
+  return _msg;
+}
+
+inline bool TypeFeedback_Feedback::has_feedback() const {
+  return feedback_case() != FEEDBACK_NOT_SET;
+}
+inline void TypeFeedback_Feedback::clear_has_feedback() {
+  _impl_._oneof_case_[0] = FEEDBACK_NOT_SET;
+}
+inline TypeFeedback_Feedback::FeedbackCase TypeFeedback_Feedback::feedback_case() const {
+  return TypeFeedback_Feedback::FeedbackCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// TypeFeedback
+
+// map<int64, .TypeFeedback.Feedback> types = 2;
+inline int TypeFeedback::_internal_types_size() const {
+  return _impl_.types_.size();
+}
+inline int TypeFeedback::types_size() const {
+  return _internal_types_size();
+}
+inline void TypeFeedback::clear_types() {
+  _impl_.types_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+TypeFeedback::_internal_types() const {
+  return _impl_.types_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+TypeFeedback::types() const {
+  // @@protoc_insertion_point(field_map:TypeFeedback.types)
+  return _internal_types();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+TypeFeedback::_internal_mutable_types() {
+  return _impl_.types_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+TypeFeedback::mutable_types() {
+  // @@protoc_insertion_point(field_mutable_map:TypeFeedback.types)
+  return _internal_mutable_types();
+}
+
+// -------------------------------------------------------------------
+
+// FeedbackRequest
+
+// .Function function = 1;
+inline bool FeedbackRequest::_internal_has_function() const {
+  return this != internal_default_instance() && _impl_.function_ != nullptr;
+}
+inline bool FeedbackRequest::has_function() const {
+  return _internal_has_function();
+}
+inline void FeedbackRequest::clear_function() {
+  if (GetArenaForAllocation() == nullptr && _impl_.function_ != nullptr) {
+    delete _impl_.function_;
+  }
+  _impl_.function_ = nullptr;
+}
+inline const ::Function& FeedbackRequest::_internal_function() const {
+  const ::Function* p = _impl_.function_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Function&>(
+      ::_Function_default_instance_);
+}
+inline const ::Function& FeedbackRequest::function() const {
+  // @@protoc_insertion_point(field_get:FeedbackRequest.function)
+  return _internal_function();
+}
+inline void FeedbackRequest::unsafe_arena_set_allocated_function(
+    ::Function* function) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_);
+  }
+  _impl_.function_ = function;
+  if (function) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FeedbackRequest.function)
+}
+inline ::Function* FeedbackRequest::release_function() {
+  
+  ::Function* temp = _impl_.function_;
+  _impl_.function_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Function* FeedbackRequest::unsafe_arena_release_function() {
+  // @@protoc_insertion_point(field_release:FeedbackRequest.function)
+  
+  ::Function* temp = _impl_.function_;
+  _impl_.function_ = nullptr;
+  return temp;
+}
+inline ::Function* FeedbackRequest::_internal_mutable_function() {
+  
+  if (_impl_.function_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Function>(GetArenaForAllocation());
+    _impl_.function_ = p;
+  }
+  return _impl_.function_;
+}
+inline ::Function* FeedbackRequest::mutable_function() {
+  ::Function* _msg = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:FeedbackRequest.function)
+  return _msg;
+}
+inline void FeedbackRequest::set_allocated_function(::Function* function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.function_;
+  }
+  if (function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(function);
+    if (message_arena != submessage_arena) {
+      function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, function, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.function_ = function;
+  // @@protoc_insertion_point(field_set_allocated:FeedbackRequest.function)
+}
+
+// -------------------------------------------------------------------
+
+// PackageSource
+
+// string r_mirror = 2;
+inline bool PackageSource::_internal_has_r_mirror() const {
+  return source_case() == kRMirror;
+}
+inline bool PackageSource::has_r_mirror() const {
+  return _internal_has_r_mirror();
+}
+inline void PackageSource::set_has_r_mirror() {
+  _impl_._oneof_case_[0] = kRMirror;
+}
+inline void PackageSource::clear_r_mirror() {
+  if (_internal_has_r_mirror()) {
+    _impl_.source_.r_mirror_.Destroy();
+    clear_has_source();
+  }
+}
+inline const std::string& PackageSource::r_mirror() const {
+  // @@protoc_insertion_point(field_get:PackageSource.r_mirror)
+  return _internal_r_mirror();
+}
+template <typename ArgT0, typename... ArgT>
+inline void PackageSource::set_r_mirror(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_r_mirror()) {
+    clear_source();
+    set_has_r_mirror();
+    _impl_.source_.r_mirror_.InitDefault();
+  }
+  _impl_.source_.r_mirror_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:PackageSource.r_mirror)
+}
+inline std::string* PackageSource::mutable_r_mirror() {
+  std::string* _s = _internal_mutable_r_mirror();
+  // @@protoc_insertion_point(field_mutable:PackageSource.r_mirror)
+  return _s;
+}
+inline const std::string& PackageSource::_internal_r_mirror() const {
+  if (_internal_has_r_mirror()) {
+    return _impl_.source_.r_mirror_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PackageSource::_internal_set_r_mirror(const std::string& value) {
+  if (!_internal_has_r_mirror()) {
+    clear_source();
+    set_has_r_mirror();
+    _impl_.source_.r_mirror_.InitDefault();
+  }
+  _impl_.source_.r_mirror_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PackageSource::_internal_mutable_r_mirror() {
+  if (!_internal_has_r_mirror()) {
+    clear_source();
+    set_has_r_mirror();
+    _impl_.source_.r_mirror_.InitDefault();
+  }
+  return _impl_.source_.r_mirror_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* PackageSource::release_r_mirror() {
+  // @@protoc_insertion_point(field_release:PackageSource.r_mirror)
+  if (_internal_has_r_mirror()) {
+    clear_has_source();
+    return _impl_.source_.r_mirror_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void PackageSource::set_allocated_r_mirror(std::string* r_mirror) {
+  if (has_source()) {
+    clear_source();
+  }
+  if (r_mirror != nullptr) {
+    set_has_r_mirror();
+    _impl_.source_.r_mirror_.InitAllocated(r_mirror, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:PackageSource.r_mirror)
+}
+
+// string github_url = 3;
+inline bool PackageSource::_internal_has_github_url() const {
+  return source_case() == kGithubUrl;
+}
+inline bool PackageSource::has_github_url() const {
+  return _internal_has_github_url();
+}
+inline void PackageSource::set_has_github_url() {
+  _impl_._oneof_case_[0] = kGithubUrl;
+}
+inline void PackageSource::clear_github_url() {
+  if (_internal_has_github_url()) {
+    _impl_.source_.github_url_.Destroy();
+    clear_has_source();
+  }
+}
+inline const std::string& PackageSource::github_url() const {
+  // @@protoc_insertion_point(field_get:PackageSource.github_url)
+  return _internal_github_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline void PackageSource::set_github_url(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_github_url()) {
+    clear_source();
+    set_has_github_url();
+    _impl_.source_.github_url_.InitDefault();
+  }
+  _impl_.source_.github_url_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:PackageSource.github_url)
+}
+inline std::string* PackageSource::mutable_github_url() {
+  std::string* _s = _internal_mutable_github_url();
+  // @@protoc_insertion_point(field_mutable:PackageSource.github_url)
+  return _s;
+}
+inline const std::string& PackageSource::_internal_github_url() const {
+  if (_internal_has_github_url()) {
+    return _impl_.source_.github_url_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PackageSource::_internal_set_github_url(const std::string& value) {
+  if (!_internal_has_github_url()) {
+    clear_source();
+    set_has_github_url();
+    _impl_.source_.github_url_.InitDefault();
+  }
+  _impl_.source_.github_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PackageSource::_internal_mutable_github_url() {
+  if (!_internal_has_github_url()) {
+    clear_source();
+    set_has_github_url();
+    _impl_.source_.github_url_.InitDefault();
+  }
+  return _impl_.source_.github_url_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* PackageSource::release_github_url() {
+  // @@protoc_insertion_point(field_release:PackageSource.github_url)
+  if (_internal_has_github_url()) {
+    clear_has_source();
+    return _impl_.source_.github_url_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void PackageSource::set_allocated_github_url(std::string* github_url) {
+  if (has_source()) {
+    clear_source();
+  }
+  if (github_url != nullptr) {
+    set_has_github_url();
+    _impl_.source_.github_url_.InitAllocated(github_url, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:PackageSource.github_url)
+}
+
+inline bool PackageSource::has_source() const {
+  return source_case() != SOURCE_NOT_SET;
+}
+inline void PackageSource::clear_has_source() {
+  _impl_._oneof_case_[0] = SOURCE_NOT_SET;
+}
+inline PackageSource::SourceCase PackageSource::source_case() const {
+  return PackageSource::SourceCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Package
+
+// string name = 1;
+inline void Package::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Package::name() const {
+  // @@protoc_insertion_point(field_get:Package.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Package::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:Package.name)
+}
+inline std::string* Package::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:Package.name)
+  return _s;
+}
+inline const std::string& Package::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Package::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Package::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Package::release_name() {
+  // @@protoc_insertion_point(field_release:Package.name)
+  return _impl_.name_.Release();
+}
+inline void Package::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:Package.name)
+}
+
+// .Version version = 2;
+inline bool Package::_internal_has_version() const {
+  return this != internal_default_instance() && _impl_.version_ != nullptr;
+}
+inline bool Package::has_version() const {
+  return _internal_has_version();
+}
+inline void Package::clear_version() {
+  if (GetArenaForAllocation() == nullptr && _impl_.version_ != nullptr) {
+    delete _impl_.version_;
+  }
+  _impl_.version_ = nullptr;
+}
+inline const ::Version& Package::_internal_version() const {
+  const ::Version* p = _impl_.version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::Version&>(
+      ::_Version_default_instance_);
+}
+inline const ::Version& Package::version() const {
+  // @@protoc_insertion_point(field_get:Package.version)
+  return _internal_version();
+}
+inline void Package::unsafe_arena_set_allocated_version(
+    ::Version* version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
+  }
+  _impl_.version_ = version;
+  if (version) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Package.version)
+}
+inline ::Version* Package::release_version() {
+  
+  ::Version* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::Version* Package::unsafe_arena_release_version() {
+  // @@protoc_insertion_point(field_release:Package.version)
+  
+  ::Version* temp = _impl_.version_;
+  _impl_.version_ = nullptr;
+  return temp;
+}
+inline ::Version* Package::_internal_mutable_version() {
+  
+  if (_impl_.version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Version>(GetArenaForAllocation());
+    _impl_.version_ = p;
+  }
+  return _impl_.version_;
+}
+inline ::Version* Package::mutable_version() {
+  ::Version* _msg = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:Package.version)
+  return _msg;
+}
+inline void Package::set_allocated_version(::Version* version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.version_;
+  }
+  if (version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
+    if (message_arena != submessage_arena) {
+      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, version, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.version_ = version;
+  // @@protoc_insertion_point(field_set_allocated:Package.version)
+}
+
+// repeated bytes function_hashes = 4;
+inline int Package::_internal_function_hashes_size() const {
+  return _impl_.function_hashes_.size();
+}
+inline int Package::function_hashes_size() const {
+  return _internal_function_hashes_size();
+}
+inline void Package::clear_function_hashes() {
+  _impl_.function_hashes_.Clear();
+}
+inline std::string* Package::add_function_hashes() {
+  std::string* _s = _internal_add_function_hashes();
+  // @@protoc_insertion_point(field_add_mutable:Package.function_hashes)
+  return _s;
+}
+inline const std::string& Package::_internal_function_hashes(int index) const {
+  return _impl_.function_hashes_.Get(index);
+}
+inline const std::string& Package::function_hashes(int index) const {
+  // @@protoc_insertion_point(field_get:Package.function_hashes)
+  return _internal_function_hashes(index);
+}
+inline std::string* Package::mutable_function_hashes(int index) {
+  // @@protoc_insertion_point(field_mutable:Package.function_hashes)
+  return _impl_.function_hashes_.Mutable(index);
+}
+inline void Package::set_function_hashes(int index, const std::string& value) {
+  _impl_.function_hashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:Package.function_hashes)
+}
+inline void Package::set_function_hashes(int index, std::string&& value) {
+  _impl_.function_hashes_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:Package.function_hashes)
+}
+inline void Package::set_function_hashes(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.function_hashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:Package.function_hashes)
+}
+inline void Package::set_function_hashes(int index, const void* value, size_t size) {
+  _impl_.function_hashes_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:Package.function_hashes)
+}
+inline std::string* Package::_internal_add_function_hashes() {
+  return _impl_.function_hashes_.Add();
+}
+inline void Package::add_function_hashes(const std::string& value) {
+  _impl_.function_hashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:Package.function_hashes)
+}
+inline void Package::add_function_hashes(std::string&& value) {
+  _impl_.function_hashes_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:Package.function_hashes)
+}
+inline void Package::add_function_hashes(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.function_hashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:Package.function_hashes)
+}
+inline void Package::add_function_hashes(const void* value, size_t size) {
+  _impl_.function_hashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:Package.function_hashes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Package::function_hashes() const {
+  // @@protoc_insertion_point(field_list:Package.function_hashes)
+  return _impl_.function_hashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Package::mutable_function_hashes() {
+  // @@protoc_insertion_point(field_mutable_list:Package.function_hashes)
+  return &_impl_.function_hashes_;
+}
+
+// optional .PackageSource source = 5;
+inline bool Package::_internal_has_source() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.source_ != nullptr);
+  return value;
+}
+inline bool Package::has_source() const {
+  return _internal_has_source();
+}
+inline void Package::clear_source() {
+  if (_impl_.source_ != nullptr) _impl_.source_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::PackageSource& Package::_internal_source() const {
+  const ::PackageSource* p = _impl_.source_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PackageSource&>(
+      ::_PackageSource_default_instance_);
+}
+inline const ::PackageSource& Package::source() const {
+  // @@protoc_insertion_point(field_get:Package.source)
+  return _internal_source();
+}
+inline void Package::unsafe_arena_set_allocated_source(
+    ::PackageSource* source) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_);
+  }
+  _impl_.source_ = source;
+  if (source) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Package.source)
+}
+inline ::PackageSource* Package::release_source() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::PackageSource* temp = _impl_.source_;
+  _impl_.source_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PackageSource* Package::unsafe_arena_release_source() {
+  // @@protoc_insertion_point(field_release:Package.source)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::PackageSource* temp = _impl_.source_;
+  _impl_.source_ = nullptr;
+  return temp;
+}
+inline ::PackageSource* Package::_internal_mutable_source() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.source_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PackageSource>(GetArenaForAllocation());
+    _impl_.source_ = p;
+  }
+  return _impl_.source_;
+}
+inline ::PackageSource* Package::mutable_source() {
+  ::PackageSource* _msg = _internal_mutable_source();
+  // @@protoc_insertion_point(field_mutable:Package.source)
+  return _msg;
+}
+inline void Package::set_allocated_source(::PackageSource* source) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.source_;
+  }
+  if (source) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source);
+    if (message_arena != submessage_arena) {
+      source = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, source, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.source_ = source;
+  // @@protoc_insertion_point(field_set_allocated:Package.source)
+}
+
+// -------------------------------------------------------------------
+
+// PackageRequest
+
+// bytes hash = 1;
+inline void PackageRequest::clear_hash() {
+  _impl_.hash_.ClearToEmpty();
+}
+inline const std::string& PackageRequest::hash() const {
+  // @@protoc_insertion_point(field_get:PackageRequest.hash)
+  return _internal_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackageRequest::set_hash(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:PackageRequest.hash)
+}
+inline std::string* PackageRequest::mutable_hash() {
+  std::string* _s = _internal_mutable_hash();
+  // @@protoc_insertion_point(field_mutable:PackageRequest.hash)
+  return _s;
+}
+inline const std::string& PackageRequest::_internal_hash() const {
+  return _impl_.hash_.Get();
+}
+inline void PackageRequest::_internal_set_hash(const std::string& value) {
+  
+  _impl_.hash_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PackageRequest::_internal_mutable_hash() {
+  
+  return _impl_.hash_.Mutable(GetArenaForAllocation());
+}
+inline std::string* PackageRequest::release_hash() {
+  // @@protoc_insertion_point(field_release:PackageRequest.hash)
+  return _impl_.hash_.Release();
+}
+inline void PackageRequest::set_allocated_hash(std::string* hash) {
+  if (hash != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hash_.IsDefault()) {
+    _impl_.hash_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:PackageRequest.hash)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::Tier> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Tier>() {
+  return ::Tier_descriptor();
+}
+template <> struct is_proto_enum< ::TestLattice> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::TestLattice>() {
+  return ::TestLattice_descriptor();
+}
+template <> struct is_proto_enum< ::Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Type>() {
+  return ::Type_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_messages_2eproto
diff --git a/client/rsh/src/routes.pb.cc b/client/rsh/src/routes.pb.cc
new file mode 100644
index 000000000..f4b140952
--- /dev/null
+++ b/client/rsh/src/routes.pb.cc
@@ -0,0 +1,65 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: routes.proto
+
+#include "routes.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_routes_2eproto = nullptr;
+static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_routes_2eproto = nullptr;
+const uint32_t TableStruct_routes_2eproto::offsets[1] = {};
+static constexpr ::_pbi::MigrationSchema* schemas = nullptr;
+static constexpr ::_pb::Message* const* file_default_instances = nullptr;
+
+const char descriptor_table_protodef_routes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\014routes.proto\032\016messages.proto2g\n\016Compil"
+  "eService\022.\n\007Compile\022\017.CompileRequest\032\020.C"
+  "ompileResponse\"\000\022%\n\004Init\022\014.InitRequest\032\r"
+  ".InitResponse\"\0002\303\001\n\013FactService\022)\n\nGetCo"
+  "ntext\022\017.ContextRequest\032\010.Context\"\000\0224\n\017Ge"
+  "tTypeFeedback\022\020.FeedbackRequest\032\r.TypeFe"
+  "edback\"\000\022%\n\tGetValues\022\r.ValueRequest\032\007.V"
+  "alues\"\000\022,\n\013GetFunction\022\020.FunctionRequest"
+  "\032\t.Function\"\000B\023\n\021org.prlprg.serverb\006prot"
+  "o3"
+  ;
+static const ::_pbi::DescriptorTable* const descriptor_table_routes_2eproto_deps[1] = {
+  &::descriptor_table_messages_2eproto,
+};
+static ::_pbi::once_flag descriptor_table_routes_2eproto_once;
+const ::_pbi::DescriptorTable descriptor_table_routes_2eproto = {
+    false, false, 362, descriptor_table_protodef_routes_2eproto,
+    "routes.proto",
+    &descriptor_table_routes_2eproto_once, descriptor_table_routes_2eproto_deps, 1, 0,
+    schemas, file_default_instances, TableStruct_routes_2eproto::offsets,
+    nullptr, file_level_enum_descriptors_routes_2eproto,
+    file_level_service_descriptors_routes_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_routes_2eproto_getter() {
+  return &descriptor_table_routes_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_routes_2eproto(&descriptor_table_routes_2eproto);
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/client/rsh/src/routes.pb.h b/client/rsh/src/routes.pb.h
new file mode 100644
index 000000000..471b9a9d8
--- /dev/null
+++ b/client/rsh/src/routes.pb.h
@@ -0,0 +1,71 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: routes.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_routes_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_routes_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include "messages.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_routes_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_routes_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_routes_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_routes_2eproto

From 91662a984a01f834d4aaf05b8f256177fab910c4 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 12 Aug 2024 14:53:56 +0200
Subject: [PATCH 37/80] Client initialization

---
 client/rsh/src/client.cpp | 98 ++++++++++++++++++++++++++++-----------
 client/rsh/src/client.h   | 16 +++++++
 2 files changed, 86 insertions(+), 28 deletions(-)

diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 3338817ed..958851418 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -41,43 +41,85 @@ CompileResponse remote_compile(std::string const &name,
   return response;
 }
 
-class Client {
-private:
-  std::unique_ptr<RouteGuide::Stub> stub_;
-
-public:
-  Client(std::shared_ptr<Channel> channel) : stub_(Routes::NewStub(channel)) {
-
-    // TODO: send handshake here?
-  }
-
-  CompileResponse remote_compile(std::string const& name, 
-                                std::vector<uint8_t> const &rds_closure,
-                                Tier tier,
-                                int32_t optimization_level) {
-
-    CompileRequest request;
-    request.set_tier(tier);
-    request.set_optimization_level(optimization_level);
-    request.mutable_function().set_name(name);
-    request.mutable_function().set_body(rds_closure.data(), rds_closure.size());
+Client::Client(std::shared_ptr<Channel> channel, vector<string> installed_packages) : stub_(Routes::NewStub(channel)) {
+
+    InitRequest request;
+    // Rsh version
+    request.mutable_rsh_version()->set_major(0);
+    request.mutable_rsh_version()->set_minor(1);
+    request.mutable_rsh_version()->set_patch(0);
+
+    // R version (see Rversion.h)
+    request.mutable_r_version()->set_major(R_VERSION / 65536);
+    request.mutable_r_version()->set_minor(R_VERSION % 65536 / 256);
+    request.mutable_r_version()->set_patch(R_VERSION % 256);
+
+    request.set_platform(R_PLATFORM); // Or get it from the R side? R.version would have it for instance
+    // We could also get the OS and so on
+
+    // TODO: compute hashes of package contents (maybe rdb/rdx and so on)
+    // instead of just writing package names here.
+    for(auto const& package : installed_packages) {
+      request.add_package_hash(package);
+    }
 
-    // TODO: Actually compile the hash
-    std::array<uint8_t,64> hash = {0};
-    request.mutable_function().set_hash(hash.data(), hash.size());
 
+    InitResponse response;
     ClientContext context;
-    CompileResponse response;
-    Status status = _stub->Compile(&context, request, &response);
+    Status status = _stub->Init(&context, request, &response);
     if(!status.ok()) {
       std::err << status.error_code() << ": " << status.error_message()
                 << std::endl;
-      exit(1);//TODO: rather return an optional?
+      exit(1);
     }
     else {
-      return response;
+      std::cout << "Connected to server" << std::endl;
     }
   }
-};
+
+CompileResponse Client::remote_compile(std::string const& name, 
+                              std::vector<uint8_t> const &rds_closure,
+                              Tier tier,
+                              int32_t optimization_level) {
+
+  CompileRequest request;
+  request.set_tier(tier);
+  request.set_optimization_level(optimization_level);
+  request.mutable_function().set_name(name);
+  request.mutable_function().set_body(rds_closure.data(), rds_closure.size());
+
+  // TODO: Actually compile the hash
+  std::array<uint8_t,64> hash = {0};
+  request.mutable_function().set_hash(hash.data(), hash.size());
+
+  ClientContext context;
+  CompileResponse response;
+  Status status = _stub->Compile(&context, request, &response);
+  if(!status.ok()) {
+    std::err << status.error_code() << ": " << status.error_message()
+              << std::endl;
+    exit(1);//TODO: rather return an optional?
+  }
+  else {
+    return response;
+  }
+}
+
+SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
+  auto addr = CHAR(STRING_ELT(address, 0));
+  auto p = INTEGER(port)[0];
+  std::string address_str(addr);
+  address_str += ":" + std::to_string(p);
+
+  std::vector<std::string> packages;
+  for(int i = 0; i < LENGTH(installed_packages); ++i) {
+    packages.push_back(CHAR(STRING_ELT(installed_packages, i)));
+  }
+
+  auto channel = grpc::CreateChannel(address_str, grpc::InsecureChannelCredentials());
+  auto client = new Client(channel, packages);
+  // TODO: we should also store that in a global variable as for CMP_FUN
+  return R_MakeExternalPtr(client, Rf_install("RSH_CLIENT"), R_NilValue);
+}
 
 } // namespace rsh
diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index cfca79fb0..f14b12fe6 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -3,6 +3,7 @@
 #include "rsh.h"
 #include <R.h>
 #include <Rinternals.h>
+#include <Rversion.h>
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -17,4 +18,19 @@ CompileResponse remote_compile(std::string const &name,
                                std::vector<uint8_t> const &rds_closure,
                                u32 opt_level);
 
+class Client {
+private:
+  std::unique_ptr<RouteGuide::Stub> stub_;
+
+public:
+  Client(std::shared_ptr<Channel> channel) : stub_(Routes::NewStub(channel));
+
+  CompileResponse remote_compile(std::string const& name, 
+                                std::vector<uint8_t> const &rds_closure,
+                                Tier tier,
+                                int32_t optimization_level);
+};
+
+SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
+
 } // namespace rsh

From 0cf37f8c2f74b6e28b45a6c1daddb260517cbc02 Mon Sep 17 00:00:00 2001
From: Revanth-Kumar-Vennu <vennu.r@northeastern.edu>
Date: Tue, 13 Aug 2024 17:04:13 +0000
Subject: [PATCH 38/80] Description Parsing Added

---
 .../java/org/prlprg/session/DESCRIPTION.java  | 90 +++++++++++++++++++
 .../java/org/prlprg/session/GNURSession.java  | 73 ++++++++++-----
 .../org/prlprg/rsession/DESCRIPTIONTest.java  | 81 +++++++++++++++++
 .../org/prlprg/rsession/GNURSessionTest.java  | 71 +++++++++++++--
 4 files changed, 287 insertions(+), 28 deletions(-)
 create mode 100644 server/src/main/java/org/prlprg/session/DESCRIPTION.java
 create mode 100644 server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java

diff --git a/server/src/main/java/org/prlprg/session/DESCRIPTION.java b/server/src/main/java/org/prlprg/session/DESCRIPTION.java
new file mode 100644
index 000000000..8a2efe0e6
--- /dev/null
+++ b/server/src/main/java/org/prlprg/session/DESCRIPTION.java
@@ -0,0 +1,90 @@
+
+package org.prlprg.session;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** DESCRIPTION file parser. */
+public class DESCRIPTION {
+    private String version;
+    private final List<String> suggests;
+    private final List<String> imports;
+
+    public DESCRIPTION(Path descriptionFile) throws IOException {
+        this.suggests = new ArrayList<>();
+        this.imports = new ArrayList<>();
+        parseDescriptionFile(descriptionFile);
+    }
+
+    /**
+     * Parses the DESCRIPTION file.
+     *
+     * @param descriptionFile the path to the DESCRIPTION file
+     * @throws IOException if an I/O error occurs
+     */
+    private void parseDescriptionFile(Path descriptionFile) throws IOException {
+        List<String> lines = Files.readAllLines(descriptionFile);
+        Pattern versionPattern = Pattern.compile("^Version:\\s*(.*)$");
+        Pattern suggestsPattern = Pattern.compile("^Suggests:\\s*(.*)$");
+        Pattern importsPattern = Pattern.compile("^Imports:\\s*(.*)$");
+
+        for (String line : lines) {
+            Matcher versionMatcher = versionPattern.matcher(line);
+            Matcher suggestsMatcher = suggestsPattern.matcher(line);
+            Matcher importsMatcher = importsPattern.matcher(line);
+
+            if (versionMatcher.find()) {
+                this.version = versionMatcher.group(1).trim();
+            } else if (suggestsMatcher.find()) {
+                parsePackages(suggestsMatcher.group(1).trim(), this.suggests);
+            } else if (importsMatcher.find()) {
+                parsePackages(importsMatcher.group(1).trim(), this.imports);
+            }
+        }
+    }
+
+    /**
+     * Parses a comma-separated list of packages.
+     *
+     * @param packages the comma-separated list of packages
+     * @param list the list to add the packages to
+     */
+    private void parsePackages(String packages, List<String> list) {
+        String[] packageArray = packages.split(",");
+        for (String pkg : packageArray) {
+            list.add(pkg.trim());
+        }
+    }
+
+    /**
+     * Returns the version of the package.
+     *
+     * @return the version of the package
+     */
+    public String getVersion() {
+        return version;
+    }
+
+    /**
+     * Returns the list of suggested packages.
+     *
+     * @return the list of suggested packages
+     */
+    public List<String> getSuggests() {
+        return suggests;
+    }
+
+    /**
+     * Returns the list of imported packages.
+     *
+     * @return the list of imported packages
+     */
+    public List<String> getImports() {
+        return imports;
+    }
+}
diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index 0c51e582b..344b0421e 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -1,3 +1,4 @@
+
 package org.prlprg.session;
 
 import java.io.IOException;
@@ -21,7 +22,7 @@ class DummySession implements RSession {
   private final Logger logger = Logger.getLogger(DummySession.class.getName());
   private final GlobalEnvSXP globalEnv = new GlobalEnvSXP(SEXPs.EMPTY_ENV);
   private final NamespaceEnvSXP namespaceEnv =
-      new NamespaceEnvSXP("base", "4.3.2", globalEnv, new HashMap<>());
+          new NamespaceEnvSXP("base", "4.3.2", globalEnv, new HashMap<>());
   private final BaseEnvSXP baseEnv = new BaseEnvSXP(new HashMap<>());
 
   @Override
@@ -91,17 +92,18 @@ public void setCranMirror(URI uri) {}
 
   // We should also handle installation of a package from a GitHub repo?
   public void loadPackage(String name, String version) {
-    // TODO support RLibraries with multiple paths
-    // Check if package is installed and if not install it
-    var pkgPath = RLibraries.resolve(name);
-    var pkgDir = pkgPath.toFile();
-    if (!pkgDir.exists() || !pkgDir.isDirectory()) {
-      // Check if the package exists in a repo
-      // Install the package
-      // TODO: call install.packages from GNU R
-      throw new UnsupportedOperationException("Package installation not implemented yet");
+    DESCRIPTION description = getDescription(name);
+
+    String installedVersion = description.getVersion();
+    if (!version.equals(installedVersion)) {
+      throw new RuntimeException(
+              "Version mismatch: expected " + version + " but found " + installedVersion);
     }
 
+    // Use suggests and imports as needed
+    List<String> suggests = description.getSuggests();
+    List<String> imports = description.getImports();
+
     // Make sure base is loaded
     if (baseNamespace == null) {
       loadBase();
@@ -120,8 +122,38 @@ public void loadPackage(String name, String version) {
     }
   }
 
+  private DESCRIPTION getDescription(String name) {
+    var pkgPath = RLibraries.resolve(name);
+    var pkgDir = pkgPath.toFile();
+    if (!pkgDir.exists() || !pkgDir.isDirectory()) {
+      // Check if package is installed and if not install it
+      try {
+        ProcessBuilder processBuilder =
+                new ProcessBuilder(
+                        "Rscript", "-e", "install.packages('" + name + "', repos='" + cranMirror + "')");
+        processBuilder.inheritIO();
+        Process process = processBuilder.start();
+        int exitCode = process.waitFor();
+        if (exitCode != 0) {
+          throw new RuntimeException("Failed to install package " + name);
+        }
+      } catch (IOException | InterruptedException e) {
+        throw new RuntimeException("Failed to install package " + name, e);
+      }
+    }
+
+    Path descriptionFile = pkgPath.resolve("DESCRIPTION");
+    DESCRIPTION description;
+    try {
+      description = new DESCRIPTION(descriptionFile);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+    return description;
+  }
+
   private static HashMap<String, SEXP> readPackageDatabase(
-      RSession session, Path libPath, String packageName) throws IOException {
+          RSession session, Path libPath, String packageName) throws IOException {
     var db = new PackageDatabase(session, libPath, packageName);
     return db.getBindings();
   }
@@ -165,14 +197,14 @@ public EnvSXP loadPackage(String name, String version, List<Messages.Function> f
 
     var bindings = new HashMap<String, SEXP>(functions.size());
     functions.forEach(
-        function -> {
-          try {
-            bindings.put(
-                function.getName(), (CloSXP) RDSReader.readByteString(this, function.getBody()));
-          } catch (IOException e) {
-            throw new RuntimeException(e);
-          }
-        });
+            function -> {
+              try {
+                bindings.put(
+                        function.getName(), (CloSXP) RDSReader.readByteString(this, function.getBody()));
+              } catch (IOException e) {
+                throw new RuntimeException(e);
+              }
+            });
     return new NamespaceEnvSXP(name, version, baseNamespace, bindings);
   }
 
@@ -244,9 +276,8 @@ public boolean isBuiltinInternal(String name) {
   public NamespaceEnvSXP getNamespace(String name, String version) {
     var ns = namespaces.get(name + version);
     if (ns == null) {
-      // That could also fail!
-      // In that case, ask the client to send the package content
       loadPackage(name, version);
+      // Retrieve the namespace again after loading the package
       ns = namespaces.get(name + version);
     }
     return ns;
diff --git a/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java b/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
new file mode 100644
index 000000000..3db0ddb20
--- /dev/null
+++ b/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
@@ -0,0 +1,81 @@
+package org.prlprg.rsession;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.prlprg.session.DESCRIPTION;
+
+public class DESCRIPTIONTest {
+
+    @TempDir Path tempDir;
+
+    @Test
+    public void testDescriptionParsing() throws IOException {
+        // Create a temporary DESCRIPTION file
+        Path descriptionFile = tempDir.resolve("DESCRIPTION");
+        Files.writeString(
+                descriptionFile,
+                "Package: testpkg\nVersion: 1.2.3\nSuggests: pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
+
+        // Parse the DESCRIPTION file
+        DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+        // Assert the parsed values
+        Assertions.assertEquals("1.2.3", description.getVersion());
+        Assertions.assertEquals(List.of("pkgA (>= 1.0.0)", "pkgB"), description.getSuggests());
+        Assertions.assertEquals(List.of("pkgC", "pkgD (>= 2.0.0)"), description.getImports());
+    }
+
+    @Test
+    public void testEmptySuggestsAndImports() throws IOException {
+        // Create a temporary DESCRIPTION file
+        Path descriptionFile = tempDir.resolve("DESCRIPTION");
+        Files.writeString(descriptionFile, "Package: testpkg\nVersion: 1.2.3\n");
+
+        // Parse the DESCRIPTION file
+        DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+        // Assert the parsed values
+        Assertions.assertEquals("1.2.3", description.getVersion());
+        Assertions.assertTrue(description.getSuggests().isEmpty());
+        Assertions.assertTrue(description.getImports().isEmpty());
+    }
+
+    @Test
+    public void testNoVersion() throws IOException {
+        // Create a temporary DESCRIPTION file
+        Path descriptionFile = tempDir.resolve("DESCRIPTION");
+        Files.writeString(
+                descriptionFile,
+                "Package: testpkg\nSuggests: pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
+
+        // Parse the DESCRIPTION file
+        DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+        // Assert the parsed values
+        Assertions.assertNull(description.getVersion());
+        Assertions.assertEquals(List.of("pkgA (>= 1.0.0)", "pkgB"), description.getSuggests());
+        Assertions.assertEquals(List.of("pkgC", "pkgD (>= 2.0.0)"), description.getImports());
+    }
+
+    @Test
+    public void testMalformedDescription() throws IOException {
+        // Create a temporary DESCRIPTION file
+        Path descriptionFile = tempDir.resolve("DESCRIPTION");
+        Files.writeString(
+                descriptionFile,
+                "Package: testpkg\nVersion: 1.2.3\nSuggests pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
+
+        // Parse the DESCRIPTION file
+        DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+        // Assert the parsed values
+        Assertions.assertEquals("1.2.3", description.getVersion());
+        Assertions.assertTrue(description.getSuggests().isEmpty());
+        Assertions.assertEquals(List.of("pkgC", "pkgD (>= 2.0.0)"), description.getImports());
+    }
+}
\ No newline at end of file
diff --git a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 1ea06fcce..6da9cb075 100644
--- a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -1,35 +1,92 @@
-package org.prlprg.rsession;
 
-import static org.prlprg.AppConfig.R_LIBS;
+package org.prlprg.rsession;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 import org.prlprg.RVersion;
 import org.prlprg.session.GNURSession;
 
 public class GNURSessionTest {
   private static final String R_HOME = System.getenv("R_HOME");
+  @TempDir Path tempDir;
 
   @Test
   public void testReadPackageDatabase() throws IOException {
-    var p = Path.of("/usr/lib/R/");
-    var session = new GNURSession(RVersion.LATEST_AWARE, p, R_LIBS.get(0));
+    var r_dir = Path.of("/usr/local/lib/R/");
+    var lib_dir = "/usr/local/lib/R/library/";
+    //    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
+    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
-    session.loadPackage("yaml", "2.3.8");
+    session.loadPackage("yaml", "2.3.10");
 
-    var ns = session.getNamespace("yaml", "2.3.8");
+    var ns = session.getNamespace("yaml", "2.3.10");
 
     Assertions.assertFalse(ns.bindings().isEmpty());
   }
 
   @Test
   public void testLoadBase() throws IOException {
-    var p = Path.of("/usr/lib/R/");
+    var p = Path.of("/usr/local/lib/R/");
     var session = new GNURSession(RVersion.LATEST_AWARE, p, null);
     session.loadBase();
 
     Assertions.assertFalse(session.baseNamespace().isEmpty());
   }
+
+  @Test
+  public void testVersionMismatch() {
+    var r_dir = Path.of("/usr/local/lib/R/");
+    var lib_dir = "/usr/local/lib/R/library/";
+    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+
+    Assertions.assertThrows(
+            RuntimeException.class,
+            () -> {
+              session.loadPackage("yaml", "1.0.0");
+            });
+  }
+
+  @Test
+  public void testLoadNonInstalledPackage() throws IOException, InterruptedException {
+    var r_dir = Path.of("/usr/local/lib/R/");
+    var lib_dir = "/usr/local/lib/R/library/";
+    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+
+    // Assuming "nonexistentpkg" is not installed
+    Assertions.assertThrows(
+            RuntimeException.class,
+            () -> {
+              session.loadPackage("nonexistentpkg", "1.0.0");
+            });
+  }
+
+  @Test
+  public void testRetrieveNamespaceAfterLoadingPackage() throws IOException {
+    var r_dir = Path.of("/usr/local/lib/R/");
+    var lib_dir = "/usr/local/lib/R/library/";
+    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+
+    session.loadPackage("yaml", "2.3.10");
+
+    var ns = session.getNamespace("yaml", "2.3.10");
+
+    Assertions.assertNotNull(ns);
+  }
+
+  @Test
+  public void testMissingDescriptionFile() {
+    var r_dir = Path.of("/usr/local/lib/R/");
+    var lib_dir = "/usr/local/lib/R/library/";
+    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+
+    // Assuming "pkgwithnomissingdesc" has no DESCRIPTION file
+    Assertions.assertThrows(
+            RuntimeException.class,
+            () -> {
+              session.loadPackage("pkgwithnomissingdesc", "1.0.0");
+            });
+  }
 }

From fd4300bda0450839db640a900aafa9283f81ed95 Mon Sep 17 00:00:00 2001
From: Revanth-Kumar-Vennu <vennu.r@northeastern.edu>
Date: Fri, 23 Aug 2024 20:54:50 +0000
Subject: [PATCH 39/80] Changes made according to the review

---
 .../java/org/prlprg/session/DESCRIPTION.java  | 37 ++++++++++++-------
 .../org/prlprg/rsession/DESCRIPTIONTest.java  | 19 +++++-----
 2 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/server/src/main/java/org/prlprg/session/DESCRIPTION.java b/server/src/main/java/org/prlprg/session/DESCRIPTION.java
index 8a2efe0e6..a184423f1 100644
--- a/server/src/main/java/org/prlprg/session/DESCRIPTION.java
+++ b/server/src/main/java/org/prlprg/session/DESCRIPTION.java
@@ -5,6 +5,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -12,12 +13,17 @@
 /** DESCRIPTION file parser. */
 public class DESCRIPTION {
     private String version;
-    private final List<String> suggests;
-    private final List<String> imports;
+    private final HashMap<String, String> suggests;
+    private final HashMap<String, String> imports;
+
+    private static final Pattern versionPattern = Pattern.compile("^Version:\\s*(.*)$");
+    private static final Pattern suggestsPattern = Pattern.compile("^Suggests:\\s*(.*)$");
+    private static final Pattern importsPattern = Pattern.compile("^Imports:\\s*(.*)$");
+    private static final Pattern versionRequirementPattern = Pattern.compile("([a-zA-Z0-9]+)\\s*\\((>=|=|>|<=|<)\\s*([0-9\\.]+)\\)");
 
     public DESCRIPTION(Path descriptionFile) throws IOException {
-        this.suggests = new ArrayList<>();
-        this.imports = new ArrayList<>();
+        this.suggests = new HashMap<>();
+        this.imports = new HashMap<>();
         parseDescriptionFile(descriptionFile);
     }
 
@@ -29,9 +35,6 @@ public DESCRIPTION(Path descriptionFile) throws IOException {
      */
     private void parseDescriptionFile(Path descriptionFile) throws IOException {
         List<String> lines = Files.readAllLines(descriptionFile);
-        Pattern versionPattern = Pattern.compile("^Version:\\s*(.*)$");
-        Pattern suggestsPattern = Pattern.compile("^Suggests:\\s*(.*)$");
-        Pattern importsPattern = Pattern.compile("^Imports:\\s*(.*)$");
 
         for (String line : lines) {
             Matcher versionMatcher = versionPattern.matcher(line);
@@ -49,18 +52,24 @@ private void parseDescriptionFile(Path descriptionFile) throws IOException {
     }
 
     /**
-     * Parses a comma-separated list of packages.
+     * Parses a comma-separated list of packages with version requirements.
      *
      * @param packages the comma-separated list of packages
-     * @param list the list to add the packages to
+     * @param map the map to add the packages and their version requirements to
      */
-    private void parsePackages(String packages, List<String> list) {
+    private void parsePackages(String packages, HashMap<String, String> map) {
         String[] packageArray = packages.split(",");
         for (String pkg : packageArray) {
-            list.add(pkg.trim());
+            Matcher matcher = versionRequirementPattern.matcher(pkg.trim());
+            if (matcher.find()) {
+                map.put(matcher.group(1).trim(), matcher.group(2).trim() + " " + matcher.group(3).trim());
+            } else {
+                map.put(pkg.trim(), "");
+            }
         }
     }
 
+
     /**
      * Returns the version of the package.
      *
@@ -75,7 +84,7 @@ public String getVersion() {
      *
      * @return the list of suggested packages
      */
-    public List<String> getSuggests() {
+    public HashMap<String,String> getSuggests() {
         return suggests;
     }
 
@@ -84,7 +93,7 @@ public List<String> getSuggests() {
      *
      * @return the list of imported packages
      */
-    public List<String> getImports() {
+    public HashMap<String, String> getImports() {
         return imports;
     }
-}
+}
\ No newline at end of file
diff --git a/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java b/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
index 3db0ddb20..06ab1e111 100644
--- a/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
+++ b/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
@@ -1,14 +1,15 @@
 package org.prlprg.rsession;
 
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.prlprg.session.DESCRIPTION;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+
 public class DESCRIPTIONTest {
 
     @TempDir Path tempDir;
@@ -26,8 +27,8 @@ public void testDescriptionParsing() throws IOException {
 
         // Assert the parsed values
         Assertions.assertEquals("1.2.3", description.getVersion());
-        Assertions.assertEquals(List.of("pkgA (>= 1.0.0)", "pkgB"), description.getSuggests());
-        Assertions.assertEquals(List.of("pkgC", "pkgD (>= 2.0.0)"), description.getImports());
+        Assertions.assertEquals(Map.of("pkgA", ">= 1.0.0", "pkgB", ""), description.getSuggests());
+        Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
     }
 
     @Test
@@ -58,8 +59,8 @@ public void testNoVersion() throws IOException {
 
         // Assert the parsed values
         Assertions.assertNull(description.getVersion());
-        Assertions.assertEquals(List.of("pkgA (>= 1.0.0)", "pkgB"), description.getSuggests());
-        Assertions.assertEquals(List.of("pkgC", "pkgD (>= 2.0.0)"), description.getImports());
+        Assertions.assertEquals(Map.of("pkgA", ">= 1.0.0", "pkgB", ""), description.getSuggests());
+        Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
     }
 
     @Test
@@ -76,6 +77,6 @@ public void testMalformedDescription() throws IOException {
         // Assert the parsed values
         Assertions.assertEquals("1.2.3", description.getVersion());
         Assertions.assertTrue(description.getSuggests().isEmpty());
-        Assertions.assertEquals(List.of("pkgC", "pkgD (>= 2.0.0)"), description.getImports());
+        Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
     }
 }
\ No newline at end of file

From 325bdacb0d6ebd54036862c019430cbf31f716e5 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 2 Sep 2024 16:10:59 +0200
Subject: [PATCH 40/80] Correctly compiling grpc C++ side

---
 client/rsh/src/Makevars                       |    6 +-
 client/rsh/src/client.cpp                     |   75 +-
 client/rsh/src/client.h                       |   21 +-
 client/rsh/src/messages.pb.cc                 | 1280 +++++++-------
 client/rsh/src/messages.pb.h                  | 1556 +++++++++--------
 client/rsh/src/routes.grpc.pb.cc              |  317 ++++
 client/rsh/src/routes.grpc.pb.h               | 1080 ++++++++++++
 client/rsh/src/routes.pb.cc                   |   34 +-
 client/rsh/src/routes.pb.h                    |    4 +
 proto/Makefile                                |    3 +-
 proto/messages.proto                          |    2 +
 proto/routes.proto                            |    2 +
 .../src/main/java/org/prlprg/rds/AltRep.java  |    2 +-
 .../java/org/prlprg/session/DESCRIPTION.java  |  150 +-
 .../java/org/prlprg/session/GNURSession.java  |   27 +-
 .../org/prlprg/rsession/DESCRIPTIONTest.java  |  145 +-
 .../org/prlprg/rsession/GNURSessionTest.java  |   25 +-
 17 files changed, 3068 insertions(+), 1661 deletions(-)
 create mode 100644 client/rsh/src/routes.grpc.pb.cc
 create mode 100644 client/rsh/src/routes.grpc.pb.h

diff --git a/client/rsh/src/Makevars b/client/rsh/src/Makevars
index a4beb1d42..ce1a01b00 100644
--- a/client/rsh/src/Makevars
+++ b/client/rsh/src/Makevars
@@ -5,7 +5,9 @@ LLVM_LIBS != $(LLVM_CONFIG) --libs
 
 PB_CPPFLAGS != pkg-config --cflags protobuf
 PB_LIBS != pkg-config --libs protobuf
+GRPC_CPPFLAGS != pkg-config --cflags grpc 
+GRPC_LIBS != pkg-config --libs grpc
 
-PKG_CPPFLAGS := $(LLVM_CPPFLAGS) $(PB_CPPFLAGS) -fexceptions -I../inst -DR_NO_REMAP -DSTRICT_R_HEADERS
-PKG_LIBS := $(LLVM_LIBS) $(PB_LIBS) -lzmq
+PKG_CPPFLAGS := $(LLVM_CPPFLAGS) $(PB_CPPFLAGS) $(GRPC_CPPFLAGS) -fexceptions -I../inst -DR_NO_REMAP -DSTRICT_R_HEADERS
+PKG_LIBS := $(LLVM_LIBS) $(PB_LIBS) $(GRPC_LIBS) -lzmq
 
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 958851418..38595a05f 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -1,48 +1,16 @@
 #include "client.h"
-#include "messages.pb.h"
-#include "routes.pb.h"
+
+#include <grpc/grpc.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/create_channel.h>
 #include <iostream>
 
 namespace rsh {
 
-using namespace server::protocol;
-
-CompileResponse remote_compile(std::string const &name,
-                               std::vector<uint8_t> const &rds_closure,
-                               u32 opt_level) {
-  zmq::context_t context(1);
-  zmq::socket_t socket(context, zmq::socket_type::req);
-
-  std::cout << "Connecting to compile server..." << std::endl;
-  socket.connect("tcp://localhost:5555");
-
-  Request request;
-  request.mutable_compile()->set_name(name);
-  request.mutable_compile()->set_bc_optimization(3);
-  request.mutable_compile()->set_cc_optimization(opt_level);
-  request.mutable_compile()->set_closure(rds_closure.data(),
-                                         rds_closure.size());
-
-  zmq::message_t msg(request.ByteSizeLong());
-  request.SerializeToArray(msg.data<uint8_t>(), msg.size());
-  socket.send(msg, zmq::send_flags::none);
-
-  zmq::message_t reply;
-  auto res = socket.recv(reply, zmq::recv_flags::none);
-  if (!res.has_value()) {
-    CompileResponse response;
-    response.set_failure("Error receiving reply");
-    return response;
-  }
-
-  CompileResponse response;
-  response.ParseFromArray(reply.data<uint8_t>(), reply.size());
-
-  return response;
-}
-
-Client::Client(std::shared_ptr<Channel> channel, vector<string> installed_packages) : stub_(Routes::NewStub(channel)) {
 
+Client::Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages) : stub_(protocol::CompileService::NewStub(channel)) {
+    using namespace protocol;
     InitRequest request;
     // Rsh version
     request.mutable_rsh_version()->set_major(0);
@@ -54,8 +22,10 @@ Client::Client(std::shared_ptr<Channel> channel, vector<string> installed_packag
     request.mutable_r_version()->set_minor(R_VERSION % 65536 / 256);
     request.mutable_r_version()->set_patch(R_VERSION % 256);
 
-    request.set_platform(R_PLATFORM); // Or get it from the R side? R.version would have it for instance
-    // We could also get the OS and so on
+    SEXP r_platform = Rf_eval(Rf_lang1(Rf_install("R.version")), R_BaseEnv);
+    // we could also extract the R version from there
+    // the platform is R.version$platform and is the st element of the list
+    request.set_platform(CHAR(STRING_ELT(VECTOR_ELT(r_platform, 0), 0))); // or R_PLATFORM?
 
     // TODO: compute hashes of package contents (maybe rdb/rdx and so on)
     // instead of just writing package names here.
@@ -65,10 +35,10 @@ Client::Client(std::shared_ptr<Channel> channel, vector<string> installed_packag
 
 
     InitResponse response;
-    ClientContext context;
-    Status status = _stub->Init(&context, request, &response);
+    grpc::ClientContext context;
+    grpc::Status status = stub_->Init(&context, request, &response);
     if(!status.ok()) {
-      std::err << status.error_code() << ": " << status.error_message()
+      std::cerr << status.error_code() << ": " << status.error_message()
                 << std::endl;
       exit(1);
     }
@@ -77,26 +47,27 @@ Client::Client(std::shared_ptr<Channel> channel, vector<string> installed_packag
     }
   }
 
-CompileResponse Client::remote_compile(std::string const& name, 
+protocol::CompileResponse Client::remote_compile(std::string const& name, 
                               std::vector<uint8_t> const &rds_closure,
-                              Tier tier,
+                              protocol::Tier tier,
                               int32_t optimization_level) {
+  using namespace protocol;
 
   CompileRequest request;
   request.set_tier(tier);
   request.set_optimization_level(optimization_level);
-  request.mutable_function().set_name(name);
-  request.mutable_function().set_body(rds_closure.data(), rds_closure.size());
+  request.mutable_function()->set_name(name);
+  request.mutable_function()->set_body(rds_closure.data(), rds_closure.size());
 
   // TODO: Actually compile the hash
   std::array<uint8_t,64> hash = {0};
-  request.mutable_function().set_hash(hash.data(), hash.size());
+  request.mutable_function()->set_hash(hash.data(), hash.size());
 
-  ClientContext context;
+  grpc::ClientContext context;
   CompileResponse response;
-  Status status = _stub->Compile(&context, request, &response);
+  grpc::Status status = stub_->Compile(&context, request, &response);
   if(!status.ok()) {
-    std::err << status.error_code() << ": " << status.error_message()
+    std::cerr << status.error_code() << ": " << status.error_message()
               << std::endl;
     exit(1);//TODO: rather return an optional?
   }
diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index f14b12fe6..850aebca9 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -1,5 +1,7 @@
 #pragma once
-#include "protocol.pb.h"
+#include "messages.pb.h"
+#include "routes.pb.h"
+#include "routes.grpc.pb.h"
 #include "rsh.h"
 #include <R.h>
 #include <Rinternals.h>
@@ -8,26 +10,21 @@
 #include <string>
 #include <vector>
 #include <zmq.hpp>
+#include <grpc/grpc.h>
+#include <grpcpp/channel.h>
 
 namespace rsh {
 
-using namespace server::protocol;
-
-// TODO: compiler a CLOSXP
-CompileResponse remote_compile(std::string const &name,
-                               std::vector<uint8_t> const &rds_closure,
-                               u32 opt_level);
-
 class Client {
 private:
-  std::unique_ptr<RouteGuide::Stub> stub_;
+  std::unique_ptr<protocol::CompileService::Stub> stub_;
 
 public:
-  Client(std::shared_ptr<Channel> channel) : stub_(Routes::NewStub(channel));
+  Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages);
 
-  CompileResponse remote_compile(std::string const& name, 
+  protocol::CompileResponse remote_compile(std::string const& name, 
                                 std::vector<uint8_t> const &rds_closure,
-                                Tier tier,
+                                protocol::Tier tier,
                                 int32_t optimization_level);
 };
 
diff --git a/client/rsh/src/messages.pb.cc b/client/rsh/src/messages.pb.cc
index 7b7ff64c6..c726850e8 100644
--- a/client/rsh/src/messages.pb.cc
+++ b/client/rsh/src/messages.pb.cc
@@ -20,6 +20,8 @@ PROTOBUF_PRAGMA_INIT_SEG
 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
 namespace _pbi = _pb::internal;
 
+namespace rsh {
+namespace protocol {
 PROTOBUF_CONSTEXPR Version::Version(
     ::_pbi::ConstantInitialized): _impl_{
     /*decltype(_impl_.major_)*/0
@@ -401,383 +403,393 @@ struct PackageRequestDefaultTypeInternal {
   };
 };
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PackageRequestDefaultTypeInternal _PackageRequest_default_instance_;
+}  // namespace protocol
+}  // namespace rsh
 static ::_pb::Metadata file_level_metadata_messages_2eproto[27];
 static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2eproto[3];
 static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_messages_2eproto = nullptr;
 
 const uint32_t TableStruct_messages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::Version, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Version, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Version, _impl_.major_),
-  PROTOBUF_FIELD_OFFSET(::Version, _impl_.minor_),
-  PROTOBUF_FIELD_OFFSET(::Version, _impl_.patch_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Version, _impl_.major_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Version, _impl_.minor_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Version, _impl_.patch_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::InitRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::InitRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.rsh_version_),
-  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.r_version_),
-  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.platform_),
-  PROTOBUF_FIELD_OFFSET(::InitRequest, _impl_.package_hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::InitRequest, _impl_.rsh_version_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::InitRequest, _impl_.r_version_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::InitRequest, _impl_.platform_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::InitRequest, _impl_.package_hash_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::InitResponse, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::InitResponse, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_._has_bits_),
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.function_),
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.tier_),
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.optimization_level_),
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.context_),
-  PROTOBUF_FIELD_OFFSET(::CompileRequest, _impl_.environment_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _impl_.function_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _impl_.tier_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _impl_.optimization_level_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _impl_.context_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileRequest, _impl_.environment_),
   ~0u,
   2,
   3,
   0,
   1,
-  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_._has_bits_),
-  PROTOBUF_FIELD_OFFSET(::CompileResponse, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.hash_),
-  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.tier_),
-  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.code_),
-  PROTOBUF_FIELD_OFFSET(::CompileResponse, _impl_.constant_pool_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.tier_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.code_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.constant_pool_),
   ~0u,
   ~0u,
   0,
   1,
-  PROTOBUF_FIELD_OFFSET(::Function, _impl_._has_bits_),
-  PROTOBUF_FIELD_OFFSET(::Function, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Function, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Function, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Function, _impl_.package_hash_),
-  PROTOBUF_FIELD_OFFSET(::Function, _impl_.name_),
-  PROTOBUF_FIELD_OFFSET(::Function, _impl_.hash_),
-  PROTOBUF_FIELD_OFFSET(::Function, _impl_.body_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Function, _impl_.package_hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Function, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Function, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Function, _impl_.body_),
   ~0u,
   ~0u,
   ~0u,
   0,
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::FunctionRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::FunctionRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::FunctionRequest, _impl_.hash_),
-  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, _has_bits_),
-  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::FunctionRequest, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Environment_ValuesEntry_DoNotUse, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Environment_ValuesEntry_DoNotUse, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, key_),
-  PROTOBUF_FIELD_OFFSET(::Environment_ValuesEntry_DoNotUse, value_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Environment_ValuesEntry_DoNotUse, key_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Environment_ValuesEntry_DoNotUse, value_),
   0,
   1,
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::Environment, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Environment, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Environment, _impl_.values_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Environment, _impl_.values_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::ValueRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::ValueRequest, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueRequest, _impl_.hash_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::Value, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Value, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Value, _impl_.hash_),
-  PROTOBUF_FIELD_OFFSET(::Value, _impl_.value_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Value, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Value, _impl_.value_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::Values, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Values, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Values, _impl_.values_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Values, _impl_.values_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::Empty, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Empty, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::CallContext, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallContext, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.args_statically_matched_),
-  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.correct_number_of_args_),
-  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.correct_order_of_args_),
-  PROTOBUF_FIELD_OFFSET(::CallContext, _impl_.no_missing_args_),
-  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_._has_bits_),
-  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallContext, _impl_.args_statically_matched_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallContext, _impl_.correct_number_of_args_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallContext, _impl_.correct_order_of_args_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallContext, _impl_.no_missing_args_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ArgumentContext, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ArgumentContext, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.eager_),
-  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.reflection_),
-  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.object_),
-  PROTOBUF_FIELD_OFFSET(::ArgumentContext, _impl_.type_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ArgumentContext, _impl_.eager_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ArgumentContext, _impl_.reflection_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ArgumentContext, _impl_.object_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ArgumentContext, _impl_.type_),
   ~0u,
   ~0u,
   ~0u,
   0,
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::Context, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Context, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Context, _impl_.call_context_),
-  PROTOBUF_FIELD_OFFSET(::Context, _impl_.argument_context_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Context, _impl_.call_context_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Context, _impl_.argument_context_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::ContextRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ContextRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::ContextRequest, _impl_.function_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ContextRequest, _impl_.function_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::TestFeedback, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TestFeedback, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::TestFeedback, _impl_.test_lattice_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TestFeedback, _impl_.test_lattice_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::CallFeedback, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallFeedback, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::CallFeedback, _impl_.n_calls_),
-  PROTOBUF_FIELD_OFFSET(::CallFeedback, _impl_.callee_hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallFeedback, _impl_.n_calls_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CallFeedback, _impl_.callee_hash_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueFeedback, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.scalar_),
-  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.object_),
-  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.accessed_attributes_),
-  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.vectorizable_),
-  PROTOBUF_FIELD_OFFSET(::ValueFeedback, _impl_.is_promise_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueFeedback, _impl_.scalar_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueFeedback, _impl_.object_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueFeedback, _impl_.accessed_attributes_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueFeedback, _impl_.vectorizable_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::ValueFeedback, _impl_.is_promise_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_Feedback, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_Feedback, _internal_metadata_),
   ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_Feedback, _impl_._oneof_case_[0]),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_Feedback, _impl_._oneof_case_[0]),
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
   ::_pbi::kInvalidFieldOffsetTag,
   ::_pbi::kInvalidFieldOffsetTag,
   ::_pbi::kInvalidFieldOffsetTag,
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_Feedback, _impl_.feedback_),
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, _has_bits_),
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_Feedback, _impl_.feedback_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, key_),
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback_TypesEntry_DoNotUse, value_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse, key_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse, value_),
   0,
   1,
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::TypeFeedback, _impl_.types_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::TypeFeedback, _impl_.types_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::FeedbackRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::FeedbackRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::FeedbackRequest, _impl_.function_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::FeedbackRequest, _impl_.function_),
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::PackageSource, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::PackageSource, _internal_metadata_),
   ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::PackageSource, _impl_._oneof_case_[0]),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::PackageSource, _impl_._oneof_case_[0]),
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
   ::_pbi::kInvalidFieldOffsetTag,
   ::_pbi::kInvalidFieldOffsetTag,
-  PROTOBUF_FIELD_OFFSET(::PackageSource, _impl_.source_),
-  PROTOBUF_FIELD_OFFSET(::Package, _impl_._has_bits_),
-  PROTOBUF_FIELD_OFFSET(::Package, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::PackageSource, _impl_.source_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Package, _impl_._has_bits_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Package, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::Package, _impl_.name_),
-  PROTOBUF_FIELD_OFFSET(::Package, _impl_.version_),
-  PROTOBUF_FIELD_OFFSET(::Package, _impl_.function_hashes_),
-  PROTOBUF_FIELD_OFFSET(::Package, _impl_.source_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Package, _impl_.name_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Package, _impl_.version_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Package, _impl_.function_hashes_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::Package, _impl_.source_),
   ~0u,
   ~0u,
   ~0u,
   0,
   ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::PackageRequest, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::PackageRequest, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
   ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::PackageRequest, _impl_.hash_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::PackageRequest, _impl_.hash_),
 };
 static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, -1, -1, sizeof(::Version)},
-  { 9, -1, -1, sizeof(::InitRequest)},
-  { 19, -1, -1, sizeof(::InitResponse)},
-  { 25, 36, -1, sizeof(::CompileRequest)},
-  { 41, 51, -1, sizeof(::CompileResponse)},
-  { 55, 65, -1, sizeof(::Function)},
-  { 69, -1, -1, sizeof(::FunctionRequest)},
-  { 76, 84, -1, sizeof(::Environment_ValuesEntry_DoNotUse)},
-  { 86, -1, -1, sizeof(::Environment)},
-  { 93, -1, -1, sizeof(::ValueRequest)},
-  { 100, -1, -1, sizeof(::Value)},
-  { 108, -1, -1, sizeof(::Values)},
-  { 115, -1, -1, sizeof(::Empty)},
-  { 121, -1, -1, sizeof(::CallContext)},
-  { 131, 141, -1, sizeof(::ArgumentContext)},
-  { 145, -1, -1, sizeof(::Context)},
-  { 153, -1, -1, sizeof(::ContextRequest)},
-  { 160, -1, -1, sizeof(::TestFeedback)},
-  { 167, -1, -1, sizeof(::CallFeedback)},
-  { 175, -1, -1, sizeof(::ValueFeedback)},
-  { 186, -1, -1, sizeof(::TypeFeedback_Feedback)},
-  { 196, 204, -1, sizeof(::TypeFeedback_TypesEntry_DoNotUse)},
-  { 206, -1, -1, sizeof(::TypeFeedback)},
-  { 213, -1, -1, sizeof(::FeedbackRequest)},
-  { 220, -1, -1, sizeof(::PackageSource)},
-  { 229, 239, -1, sizeof(::Package)},
-  { 243, -1, -1, sizeof(::PackageRequest)},
+  { 0, -1, -1, sizeof(::rsh::protocol::Version)},
+  { 9, -1, -1, sizeof(::rsh::protocol::InitRequest)},
+  { 19, -1, -1, sizeof(::rsh::protocol::InitResponse)},
+  { 25, 36, -1, sizeof(::rsh::protocol::CompileRequest)},
+  { 41, 51, -1, sizeof(::rsh::protocol::CompileResponse)},
+  { 55, 65, -1, sizeof(::rsh::protocol::Function)},
+  { 69, -1, -1, sizeof(::rsh::protocol::FunctionRequest)},
+  { 76, 84, -1, sizeof(::rsh::protocol::Environment_ValuesEntry_DoNotUse)},
+  { 86, -1, -1, sizeof(::rsh::protocol::Environment)},
+  { 93, -1, -1, sizeof(::rsh::protocol::ValueRequest)},
+  { 100, -1, -1, sizeof(::rsh::protocol::Value)},
+  { 108, -1, -1, sizeof(::rsh::protocol::Values)},
+  { 115, -1, -1, sizeof(::rsh::protocol::Empty)},
+  { 121, -1, -1, sizeof(::rsh::protocol::CallContext)},
+  { 131, 141, -1, sizeof(::rsh::protocol::ArgumentContext)},
+  { 145, -1, -1, sizeof(::rsh::protocol::Context)},
+  { 153, -1, -1, sizeof(::rsh::protocol::ContextRequest)},
+  { 160, -1, -1, sizeof(::rsh::protocol::TestFeedback)},
+  { 167, -1, -1, sizeof(::rsh::protocol::CallFeedback)},
+  { 175, -1, -1, sizeof(::rsh::protocol::ValueFeedback)},
+  { 186, -1, -1, sizeof(::rsh::protocol::TypeFeedback_Feedback)},
+  { 196, 204, -1, sizeof(::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse)},
+  { 206, -1, -1, sizeof(::rsh::protocol::TypeFeedback)},
+  { 213, -1, -1, sizeof(::rsh::protocol::FeedbackRequest)},
+  { 220, -1, -1, sizeof(::rsh::protocol::PackageSource)},
+  { 229, 239, -1, sizeof(::rsh::protocol::Package)},
+  { 243, -1, -1, sizeof(::rsh::protocol::PackageRequest)},
 };
 
 static const ::_pb::Message* const file_default_instances[] = {
-  &::_Version_default_instance_._instance,
-  &::_InitRequest_default_instance_._instance,
-  &::_InitResponse_default_instance_._instance,
-  &::_CompileRequest_default_instance_._instance,
-  &::_CompileResponse_default_instance_._instance,
-  &::_Function_default_instance_._instance,
-  &::_FunctionRequest_default_instance_._instance,
-  &::_Environment_ValuesEntry_DoNotUse_default_instance_._instance,
-  &::_Environment_default_instance_._instance,
-  &::_ValueRequest_default_instance_._instance,
-  &::_Value_default_instance_._instance,
-  &::_Values_default_instance_._instance,
-  &::_Empty_default_instance_._instance,
-  &::_CallContext_default_instance_._instance,
-  &::_ArgumentContext_default_instance_._instance,
-  &::_Context_default_instance_._instance,
-  &::_ContextRequest_default_instance_._instance,
-  &::_TestFeedback_default_instance_._instance,
-  &::_CallFeedback_default_instance_._instance,
-  &::_ValueFeedback_default_instance_._instance,
-  &::_TypeFeedback_Feedback_default_instance_._instance,
-  &::_TypeFeedback_TypesEntry_DoNotUse_default_instance_._instance,
-  &::_TypeFeedback_default_instance_._instance,
-  &::_FeedbackRequest_default_instance_._instance,
-  &::_PackageSource_default_instance_._instance,
-  &::_Package_default_instance_._instance,
-  &::_PackageRequest_default_instance_._instance,
+  &::rsh::protocol::_Version_default_instance_._instance,
+  &::rsh::protocol::_InitRequest_default_instance_._instance,
+  &::rsh::protocol::_InitResponse_default_instance_._instance,
+  &::rsh::protocol::_CompileRequest_default_instance_._instance,
+  &::rsh::protocol::_CompileResponse_default_instance_._instance,
+  &::rsh::protocol::_Function_default_instance_._instance,
+  &::rsh::protocol::_FunctionRequest_default_instance_._instance,
+  &::rsh::protocol::_Environment_ValuesEntry_DoNotUse_default_instance_._instance,
+  &::rsh::protocol::_Environment_default_instance_._instance,
+  &::rsh::protocol::_ValueRequest_default_instance_._instance,
+  &::rsh::protocol::_Value_default_instance_._instance,
+  &::rsh::protocol::_Values_default_instance_._instance,
+  &::rsh::protocol::_Empty_default_instance_._instance,
+  &::rsh::protocol::_CallContext_default_instance_._instance,
+  &::rsh::protocol::_ArgumentContext_default_instance_._instance,
+  &::rsh::protocol::_Context_default_instance_._instance,
+  &::rsh::protocol::_ContextRequest_default_instance_._instance,
+  &::rsh::protocol::_TestFeedback_default_instance_._instance,
+  &::rsh::protocol::_CallFeedback_default_instance_._instance,
+  &::rsh::protocol::_ValueFeedback_default_instance_._instance,
+  &::rsh::protocol::_TypeFeedback_Feedback_default_instance_._instance,
+  &::rsh::protocol::_TypeFeedback_TypesEntry_DoNotUse_default_instance_._instance,
+  &::rsh::protocol::_TypeFeedback_default_instance_._instance,
+  &::rsh::protocol::_FeedbackRequest_default_instance_._instance,
+  &::rsh::protocol::_PackageSource_default_instance_._instance,
+  &::rsh::protocol::_Package_default_instance_._instance,
+  &::rsh::protocol::_PackageRequest_default_instance_._instance,
 };
 
 const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
-  "\n\016messages.proto\"6\n\007Version\022\r\n\005major\030\001 \001"
-  "(\005\022\r\n\005minor\030\002 \001(\005\022\r\n\005patch\030\003 \001(\005\"q\n\013Init"
-  "Request\022\035\n\013Rsh_version\030\001 \001(\0132\010.Version\022\033"
-  "\n\tR_version\030\002 \001(\0132\010.Version\022\020\n\010platform\030"
-  "\003 \001(\t\022\024\n\014package_hash\030\004 \003(\014\"\016\n\014InitRespo"
-  "nse\"\354\001\n\016CompileRequest\022\033\n\010function\030\002 \001(\013"
-  "2\t.Function\022\030\n\004tier\030\004 \001(\0162\005.TierH\000\210\001\001\022\037\n"
-  "\022optimization_level\030\005 \001(\005H\001\210\001\001\022\036\n\007contex"
-  "t\030\006 \001(\0132\010.ContextH\002\210\001\001\022&\n\013environment\030\007 "
-  "\001(\0132\014.EnvironmentH\003\210\001\001B\007\n\005_tierB\025\n\023_opti"
-  "mization_levelB\n\n\010_contextB\016\n\014_environme"
-  "nt\"~\n\017CompileResponse\022\014\n\004hash\030\001 \001(\014\022\023\n\004t"
-  "ier\030\002 \001(\0162\005.Tier\022\021\n\004code\030\003 \001(\014H\000\210\001\001\022\032\n\rc"
-  "onstant_pool\030\004 \001(\014H\001\210\001\001B\007\n\005_codeB\020\n\016_con"
-  "stant_pool\"X\n\010Function\022\024\n\014package_hash\030\001"
-  " \001(\014\022\014\n\004name\030\002 \001(\t\022\014\n\004hash\030\003 \001(\014\022\021\n\004body"
-  "\030\004 \001(\014H\000\210\001\001B\007\n\005_body\"\037\n\017FunctionRequest\022"
-  "\014\n\004hash\030\001 \001(\014\"f\n\013Environment\022(\n\006values\030\001"
-  " \003(\0132\030.Environment.ValuesEntry\032-\n\013Values"
+  "\n\016messages.proto\022\014rsh.protocol\"6\n\007Versio"
+  "n\022\r\n\005major\030\001 \001(\005\022\r\n\005minor\030\002 \001(\005\022\r\n\005patch"
+  "\030\003 \001(\005\"\213\001\n\013InitRequest\022*\n\013Rsh_version\030\001 "
+  "\001(\0132\025.rsh.protocol.Version\022(\n\tR_version\030"
+  "\002 \001(\0132\025.rsh.protocol.Version\022\020\n\010platform"
+  "\030\003 \001(\t\022\024\n\014package_hash\030\004 \003(\014\"\016\n\014InitResp"
+  "onse\"\240\002\n\016CompileRequest\022(\n\010function\030\002 \001("
+  "\0132\026.rsh.protocol.Function\022%\n\004tier\030\004 \001(\0162"
+  "\022.rsh.protocol.TierH\000\210\001\001\022\037\n\022optimization"
+  "_level\030\005 \001(\005H\001\210\001\001\022+\n\007context\030\006 \001(\0132\025.rsh"
+  ".protocol.ContextH\002\210\001\001\0223\n\013environment\030\007 "
+  "\001(\0132\031.rsh.protocol.EnvironmentH\003\210\001\001B\007\n\005_"
+  "tierB\025\n\023_optimization_levelB\n\n\010_contextB"
+  "\016\n\014_environment\"\213\001\n\017CompileResponse\022\014\n\004h"
+  "ash\030\001 \001(\014\022 \n\004tier\030\002 \001(\0162\022.rsh.protocol.T"
+  "ier\022\021\n\004code\030\003 \001(\014H\000\210\001\001\022\032\n\rconstant_pool\030"
+  "\004 \001(\014H\001\210\001\001B\007\n\005_codeB\020\n\016_constant_pool\"X\n"
+  "\010Function\022\024\n\014package_hash\030\001 \001(\014\022\014\n\004name\030"
+  "\002 \001(\t\022\014\n\004hash\030\003 \001(\014\022\021\n\004body\030\004 \001(\014H\000\210\001\001B\007"
+  "\n\005_body\"\037\n\017FunctionRequest\022\014\n\004hash\030\001 \001(\014"
+  "\"s\n\013Environment\0225\n\006values\030\001 \003(\0132%.rsh.pr"
+  "otocol.Environment.ValuesEntry\032-\n\013Values"
   "Entry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014:\0028\001\"\034\n"
   "\014ValueRequest\022\014\n\004hash\030\001 \003(\014\"$\n\005Value\022\014\n\004"
-  "hash\030\001 \001(\014\022\r\n\005value\030\002 \001(\014\" \n\006Values\022\026\n\006v"
-  "alues\030\001 \003(\0132\006.Value\"\007\n\005Empty\"\206\001\n\013CallCon"
-  "text\022\037\n\027args_statically_matched\030\001 \001(\010\022\036\n"
-  "\026correct_number_of_args\030\002 \001(\010\022\035\n\025correct"
-  "_order_of_args\030\003 \001(\010\022\027\n\017no_missing_args\030"
-  "\004 \001(\010\"g\n\017ArgumentContext\022\r\n\005eager\030\001 \001(\010\022"
-  "\022\n\nreflection\030\002 \001(\010\022\016\n\006object\030\003 \001(\010\022\030\n\004t"
-  "ype\030\004 \001(\0162\005.TypeH\000\210\001\001B\007\n\005_type\"Y\n\007Contex"
-  "t\022\"\n\014call_context\030\001 \001(\0132\014.CallContext\022*\n"
-  "\020argument_context\030\002 \003(\0132\020.ArgumentContex"
-  "t\"-\n\016ContextRequest\022\033\n\010function\030\001 \001(\0132\t."
-  "Function\"2\n\014TestFeedback\022\"\n\014test_lattice"
-  "\030\001 \001(\0162\014.TestLattice\"4\n\014CallFeedback\022\017\n\007"
-  "n_calls\030\001 \001(\003\022\023\n\013callee_hash\030\002 \001(\014\"v\n\rVa"
-  "lueFeedback\022\016\n\006scalar\030\001 \001(\010\022\016\n\006object\030\002 "
-  "\001(\010\022\033\n\023accessed_attributes\030\003 \001(\010\022\024\n\014vect"
-  "orizable\030\004 \001(\010\022\022\n\nis_promise\030\005 \001(\010\"\220\002\n\014T"
-  "ypeFeedback\022\'\n\005types\030\002 \003(\0132\030.TypeFeedbac"
-  "k.TypesEntry\032\220\001\n\010Feedback\022&\n\rtest_feedba"
-  "ck\030\001 \001(\0132\r.TestFeedbackH\000\022&\n\rcall_feedba"
-  "ck\030\002 \001(\0132\r.CallFeedbackH\000\022(\n\016value_feedb"
-  "ack\030\003 \001(\0132\016.ValueFeedbackH\000B\n\n\010feedback\032"
-  "D\n\nTypesEntry\022\013\n\003key\030\001 \001(\003\022%\n\005value\030\002 \001("
-  "\0132\026.TypeFeedback.Feedback:\0028\001\".\n\017Feedbac"
-  "kRequest\022\033\n\010function\030\001 \001(\0132\t.Function\"C\n"
-  "\rPackageSource\022\022\n\010r_mirror\030\002 \001(\tH\000\022\024\n\ngi"
-  "thub_url\030\003 \001(\tH\000B\010\n\006source\"{\n\007Package\022\014\n"
-  "\004name\030\001 \001(\t\022\031\n\007version\030\002 \001(\0132\010.Version\022\027"
-  "\n\017function_hashes\030\004 \003(\014\022#\n\006source\030\005 \001(\0132"
-  "\016.PackageSourceH\000\210\001\001B\t\n\007_source\"\036\n\016Packa"
-  "geRequest\022\014\n\004hash\030\001 \001(\014*#\n\004Tier\022\014\n\010BASEL"
-  "INE\020\000\022\r\n\tOPTIMIZED\020\001*@\n\013TestLattice\022\010\n\004B"
-  "OTH\020\000\022\r\n\tONLY_TRUE\020\001\022\016\n\nONLY_FALSE\020\002\022\010\n\004"
-  "NONE\020\003*&\n\004Type\022\007\n\003ANY\020\000\022\013\n\007INTEGER\020\001\022\010\n\004"
-  "REAL\020\002B\023\n\021org.prlprg.serverb\006proto3"
+  "hash\030\001 \001(\014\022\r\n\005value\030\002 \001(\014\"-\n\006Values\022#\n\006v"
+  "alues\030\001 \003(\0132\023.rsh.protocol.Value\"\007\n\005Empt"
+  "y\"\206\001\n\013CallContext\022\037\n\027args_statically_mat"
+  "ched\030\001 \001(\010\022\036\n\026correct_number_of_args\030\002 \001"
+  "(\010\022\035\n\025correct_order_of_args\030\003 \001(\010\022\027\n\017no_"
+  "missing_args\030\004 \001(\010\"t\n\017ArgumentContext\022\r\n"
+  "\005eager\030\001 \001(\010\022\022\n\nreflection\030\002 \001(\010\022\016\n\006obje"
+  "ct\030\003 \001(\010\022%\n\004type\030\004 \001(\0162\022.rsh.protocol.Ty"
+  "peH\000\210\001\001B\007\n\005_type\"s\n\007Context\022/\n\014call_cont"
+  "ext\030\001 \001(\0132\031.rsh.protocol.CallContext\0227\n\020"
+  "argument_context\030\002 \003(\0132\035.rsh.protocol.Ar"
+  "gumentContext\":\n\016ContextRequest\022(\n\010funct"
+  "ion\030\001 \001(\0132\026.rsh.protocol.Function\"\?\n\014Tes"
+  "tFeedback\022/\n\014test_lattice\030\001 \001(\0162\031.rsh.pr"
+  "otocol.TestLattice\"4\n\014CallFeedback\022\017\n\007n_"
+  "calls\030\001 \001(\003\022\023\n\013callee_hash\030\002 \001(\014\"v\n\rValu"
+  "eFeedback\022\016\n\006scalar\030\001 \001(\010\022\016\n\006object\030\002 \001("
+  "\010\022\033\n\023accessed_attributes\030\003 \001(\010\022\024\n\014vector"
+  "izable\030\004 \001(\010\022\022\n\nis_promise\030\005 \001(\010\"\321\002\n\014Typ"
+  "eFeedback\0224\n\005types\030\002 \003(\0132%.rsh.protocol."
+  "TypeFeedback.TypesEntry\032\267\001\n\010Feedback\0223\n\r"
+  "test_feedback\030\001 \001(\0132\032.rsh.protocol.TestF"
+  "eedbackH\000\0223\n\rcall_feedback\030\002 \001(\0132\032.rsh.p"
+  "rotocol.CallFeedbackH\000\0225\n\016value_feedback"
+  "\030\003 \001(\0132\033.rsh.protocol.ValueFeedbackH\000B\n\n"
+  "\010feedback\032Q\n\nTypesEntry\022\013\n\003key\030\001 \001(\003\0222\n\005"
+  "value\030\002 \001(\0132#.rsh.protocol.TypeFeedback."
+  "Feedback:\0028\001\";\n\017FeedbackRequest\022(\n\010funct"
+  "ion\030\001 \001(\0132\026.rsh.protocol.Function\"C\n\rPac"
+  "kageSource\022\022\n\010r_mirror\030\002 \001(\tH\000\022\024\n\ngithub"
+  "_url\030\003 \001(\tH\000B\010\n\006source\"\225\001\n\007Package\022\014\n\004na"
+  "me\030\001 \001(\t\022&\n\007version\030\002 \001(\0132\025.rsh.protocol"
+  ".Version\022\027\n\017function_hashes\030\004 \003(\014\0220\n\006sou"
+  "rce\030\005 \001(\0132\033.rsh.protocol.PackageSourceH\000"
+  "\210\001\001B\t\n\007_source\"\036\n\016PackageRequest\022\014\n\004hash"
+  "\030\001 \001(\014*#\n\004Tier\022\014\n\010BASELINE\020\000\022\r\n\tOPTIMIZE"
+  "D\020\001*@\n\013TestLattice\022\010\n\004BOTH\020\000\022\r\n\tONLY_TRU"
+  "E\020\001\022\016\n\nONLY_FALSE\020\002\022\010\n\004NONE\020\003*&\n\004Type\022\007\n"
+  "\003ANY\020\000\022\013\n\007INTEGER\020\001\022\010\n\004REAL\020\002B\023\n\021org.prl"
+  "prg.serverb\006proto3"
   ;
 static ::_pbi::once_flag descriptor_table_messages_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_messages_2eproto = {
-    false, false, 2235, descriptor_table_protodef_messages_2eproto,
+    false, false, 2538, descriptor_table_protodef_messages_2eproto,
     "messages.proto",
     &descriptor_table_messages_2eproto_once, nullptr, 0, 27,
     schemas, file_default_instances, TableStruct_messages_2eproto::offsets,
@@ -790,6 +802,8 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_messages
 
 // Force running AddDescriptors() at dynamic initialization time.
 PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2eproto(&descriptor_table_messages_2eproto);
+namespace rsh {
+namespace protocol {
 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Tier_descriptor() {
   ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2eproto);
   return file_level_enum_descriptors_messages_2eproto[0];
@@ -846,7 +860,7 @@ Version::Version(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:Version)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Version)
 }
 Version::Version(const Version& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -861,7 +875,7 @@ Version::Version(const Version& from)
   ::memcpy(&_impl_.major_, &from._impl_.major_,
     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.patch_) -
     reinterpret_cast<char*>(&_impl_.major_)) + sizeof(_impl_.patch_));
-  // @@protoc_insertion_point(copy_constructor:Version)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Version)
 }
 
 inline void Version::SharedCtor(
@@ -877,7 +891,7 @@ inline void Version::SharedCtor(
 }
 
 Version::~Version() {
-  // @@protoc_insertion_point(destructor:Version)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Version)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -894,7 +908,7 @@ void Version::SetCachedSize(int size) const {
 }
 
 void Version::Clear() {
-// @@protoc_insertion_point(message_clear_start:Version)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Version)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -960,7 +974,7 @@ const char* Version::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
 
 uint8_t* Version::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Version)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Version)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -986,12 +1000,12 @@ uint8_t* Version::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Version)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Version)
   return target;
 }
 
 size_t Version::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Version)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Version)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -1026,7 +1040,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Version::GetClassData() const
 void Version::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Version*>(&to_msg);
   auto& from = static_cast<const Version&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Version)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Version)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -1044,7 +1058,7 @@ void Version::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOB
 }
 
 void Version::CopyFrom(const Version& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Version)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Version)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -1075,15 +1089,15 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Version::GetMetadata() const {
 
 class InitRequest::_Internal {
  public:
-  static const ::Version& rsh_version(const InitRequest* msg);
-  static const ::Version& r_version(const InitRequest* msg);
+  static const ::rsh::protocol::Version& rsh_version(const InitRequest* msg);
+  static const ::rsh::protocol::Version& r_version(const InitRequest* msg);
 };
 
-const ::Version&
+const ::rsh::protocol::Version&
 InitRequest::_Internal::rsh_version(const InitRequest* msg) {
   return *msg->_impl_.rsh_version_;
 }
-const ::Version&
+const ::rsh::protocol::Version&
 InitRequest::_Internal::r_version(const InitRequest* msg) {
   return *msg->_impl_.r_version_;
 }
@@ -1091,7 +1105,7 @@ InitRequest::InitRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:InitRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.InitRequest)
 }
 InitRequest::InitRequest(const InitRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -1113,12 +1127,12 @@ InitRequest::InitRequest(const InitRequest& from)
       _this->GetArenaForAllocation());
   }
   if (from._internal_has_rsh_version()) {
-    _this->_impl_.rsh_version_ = new ::Version(*from._impl_.rsh_version_);
+    _this->_impl_.rsh_version_ = new ::rsh::protocol::Version(*from._impl_.rsh_version_);
   }
   if (from._internal_has_r_version()) {
-    _this->_impl_.r_version_ = new ::Version(*from._impl_.r_version_);
+    _this->_impl_.r_version_ = new ::rsh::protocol::Version(*from._impl_.r_version_);
   }
-  // @@protoc_insertion_point(copy_constructor:InitRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.InitRequest)
 }
 
 inline void InitRequest::SharedCtor(
@@ -1139,7 +1153,7 @@ inline void InitRequest::SharedCtor(
 }
 
 InitRequest::~InitRequest() {
-  // @@protoc_insertion_point(destructor:InitRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.InitRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -1160,7 +1174,7 @@ void InitRequest::SetCachedSize(int size) const {
 }
 
 void InitRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:InitRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.InitRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -1184,7 +1198,7 @@ const char* InitRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .Version Rsh_version = 1;
+      // .rsh.protocol.Version Rsh_version = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr = ctx->ParseMessage(_internal_mutable_rsh_version(), ptr);
@@ -1192,7 +1206,7 @@ const char* InitRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
         } else
           goto handle_unusual;
         continue;
-      // .Version R_version = 2;
+      // .rsh.protocol.Version R_version = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr = ctx->ParseMessage(_internal_mutable_r_version(), ptr);
@@ -1206,7 +1220,7 @@ const char* InitRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
           auto str = _internal_mutable_platform();
           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "InitRequest.platform"));
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.protocol.InitRequest.platform"));
         } else
           goto handle_unusual;
         continue;
@@ -1249,18 +1263,18 @@ const char* InitRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
 
 uint8_t* InitRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:InitRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.InitRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .Version Rsh_version = 1;
+  // .rsh.protocol.Version Rsh_version = 1;
   if (this->_internal_has_rsh_version()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(1, _Internal::rsh_version(this),
         _Internal::rsh_version(this).GetCachedSize(), target, stream);
   }
 
-  // .Version R_version = 2;
+  // .rsh.protocol.Version R_version = 2;
   if (this->_internal_has_r_version()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(2, _Internal::r_version(this),
@@ -1272,7 +1286,7 @@ uint8_t* InitRequest::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_platform().data(), static_cast<int>(this->_internal_platform().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "InitRequest.platform");
+      "rsh.protocol.InitRequest.platform");
     target = stream->WriteStringMaybeAliased(
         3, this->_internal_platform(), target);
   }
@@ -1287,12 +1301,12 @@ uint8_t* InitRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:InitRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.InitRequest)
   return target;
 }
 
 size_t InitRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:InitRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.InitRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -1314,14 +1328,14 @@ size_t InitRequest::ByteSizeLong() const {
         this->_internal_platform());
   }
 
-  // .Version Rsh_version = 1;
+  // .rsh.protocol.Version Rsh_version = 1;
   if (this->_internal_has_rsh_version()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
         *_impl_.rsh_version_);
   }
 
-  // .Version R_version = 2;
+  // .rsh.protocol.Version R_version = 2;
   if (this->_internal_has_r_version()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -1341,7 +1355,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InitRequest::GetClassData() co
 void InitRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<InitRequest*>(&to_msg);
   auto& from = static_cast<const InitRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:InitRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.InitRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -1351,18 +1365,18 @@ void InitRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR
     _this->_internal_set_platform(from._internal_platform());
   }
   if (from._internal_has_rsh_version()) {
-    _this->_internal_mutable_rsh_version()->::Version::MergeFrom(
+    _this->_internal_mutable_rsh_version()->::rsh::protocol::Version::MergeFrom(
         from._internal_rsh_version());
   }
   if (from._internal_has_r_version()) {
-    _this->_internal_mutable_r_version()->::Version::MergeFrom(
+    _this->_internal_mutable_r_version()->::rsh::protocol::Version::MergeFrom(
         from._internal_r_version());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void InitRequest::CopyFrom(const InitRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:InitRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.InitRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -1405,13 +1419,13 @@ class InitResponse::_Internal {
 InitResponse::InitResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
-  // @@protoc_insertion_point(arena_constructor:InitResponse)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.InitResponse)
 }
 InitResponse::InitResponse(const InitResponse& from)
   : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
   InitResponse* const _this = this; (void)_this;
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:InitResponse)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.InitResponse)
 }
 
 
@@ -1441,32 +1455,32 @@ ::PROTOBUF_NAMESPACE_ID::Metadata InitResponse::GetMetadata() const {
 class CompileRequest::_Internal {
  public:
   using HasBits = decltype(std::declval<CompileRequest>()._impl_._has_bits_);
-  static const ::Function& function(const CompileRequest* msg);
+  static const ::rsh::protocol::Function& function(const CompileRequest* msg);
   static void set_has_tier(HasBits* has_bits) {
     (*has_bits)[0] |= 4u;
   }
   static void set_has_optimization_level(HasBits* has_bits) {
     (*has_bits)[0] |= 8u;
   }
-  static const ::Context& context(const CompileRequest* msg);
+  static const ::rsh::protocol::Context& context(const CompileRequest* msg);
   static void set_has_context(HasBits* has_bits) {
     (*has_bits)[0] |= 1u;
   }
-  static const ::Environment& environment(const CompileRequest* msg);
+  static const ::rsh::protocol::Environment& environment(const CompileRequest* msg);
   static void set_has_environment(HasBits* has_bits) {
     (*has_bits)[0] |= 2u;
   }
 };
 
-const ::Function&
+const ::rsh::protocol::Function&
 CompileRequest::_Internal::function(const CompileRequest* msg) {
   return *msg->_impl_.function_;
 }
-const ::Context&
+const ::rsh::protocol::Context&
 CompileRequest::_Internal::context(const CompileRequest* msg) {
   return *msg->_impl_.context_;
 }
-const ::Environment&
+const ::rsh::protocol::Environment&
 CompileRequest::_Internal::environment(const CompileRequest* msg) {
   return *msg->_impl_.environment_;
 }
@@ -1474,7 +1488,7 @@ CompileRequest::CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:CompileRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.CompileRequest)
 }
 CompileRequest::CompileRequest(const CompileRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -1490,18 +1504,18 @@ CompileRequest::CompileRequest(const CompileRequest& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   if (from._internal_has_function()) {
-    _this->_impl_.function_ = new ::Function(*from._impl_.function_);
+    _this->_impl_.function_ = new ::rsh::protocol::Function(*from._impl_.function_);
   }
   if (from._internal_has_context()) {
-    _this->_impl_.context_ = new ::Context(*from._impl_.context_);
+    _this->_impl_.context_ = new ::rsh::protocol::Context(*from._impl_.context_);
   }
   if (from._internal_has_environment()) {
-    _this->_impl_.environment_ = new ::Environment(*from._impl_.environment_);
+    _this->_impl_.environment_ = new ::rsh::protocol::Environment(*from._impl_.environment_);
   }
   ::memcpy(&_impl_.tier_, &from._impl_.tier_,
     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.optimization_level_) -
     reinterpret_cast<char*>(&_impl_.tier_)) + sizeof(_impl_.optimization_level_));
-  // @@protoc_insertion_point(copy_constructor:CompileRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.CompileRequest)
 }
 
 inline void CompileRequest::SharedCtor(
@@ -1520,7 +1534,7 @@ inline void CompileRequest::SharedCtor(
 }
 
 CompileRequest::~CompileRequest() {
-  // @@protoc_insertion_point(destructor:CompileRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.CompileRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -1540,7 +1554,7 @@ void CompileRequest::SetCachedSize(int size) const {
 }
 
 void CompileRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:CompileRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.CompileRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -1576,7 +1590,7 @@ const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .Function function = 2;
+      // .rsh.protocol.Function function = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr = ctx->ParseMessage(_internal_mutable_function(), ptr);
@@ -1584,12 +1598,12 @@ const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
         } else
           goto handle_unusual;
         continue;
-      // optional .Tier tier = 4;
+      // optional .rsh.protocol.Tier tier = 4;
       case 4:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
           uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
-          _internal_set_tier(static_cast<::Tier>(val));
+          _internal_set_tier(static_cast<::rsh::protocol::Tier>(val));
         } else
           goto handle_unusual;
         continue;
@@ -1602,7 +1616,7 @@ const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
         } else
           goto handle_unusual;
         continue;
-      // optional .Context context = 6;
+      // optional .rsh.protocol.Context context = 6;
       case 6:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
           ptr = ctx->ParseMessage(_internal_mutable_context(), ptr);
@@ -1610,7 +1624,7 @@ const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
         } else
           goto handle_unusual;
         continue;
-      // optional .Environment environment = 7;
+      // optional .rsh.protocol.Environment environment = 7;
       case 7:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
           ptr = ctx->ParseMessage(_internal_mutable_environment(), ptr);
@@ -1644,18 +1658,18 @@ const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
 
 uint8_t* CompileRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:CompileRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.CompileRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .Function function = 2;
+  // .rsh.protocol.Function function = 2;
   if (this->_internal_has_function()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(2, _Internal::function(this),
         _Internal::function(this).GetCachedSize(), target, stream);
   }
 
-  // optional .Tier tier = 4;
+  // optional .rsh.protocol.Tier tier = 4;
   if (_internal_has_tier()) {
     target = stream->EnsureSpace(target);
     target = ::_pbi::WireFormatLite::WriteEnumToArray(
@@ -1668,14 +1682,14 @@ uint8_t* CompileRequest::_InternalSerialize(
     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_optimization_level(), target);
   }
 
-  // optional .Context context = 6;
+  // optional .rsh.protocol.Context context = 6;
   if (_internal_has_context()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(6, _Internal::context(this),
         _Internal::context(this).GetCachedSize(), target, stream);
   }
 
-  // optional .Environment environment = 7;
+  // optional .rsh.protocol.Environment environment = 7;
   if (_internal_has_environment()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(7, _Internal::environment(this),
@@ -1686,19 +1700,19 @@ uint8_t* CompileRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:CompileRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.CompileRequest)
   return target;
 }
 
 size_t CompileRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:CompileRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.CompileRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // .Function function = 2;
+  // .rsh.protocol.Function function = 2;
   if (this->_internal_has_function()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -1707,21 +1721,21 @@ size_t CompileRequest::ByteSizeLong() const {
 
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x0000000fu) {
-    // optional .Context context = 6;
+    // optional .rsh.protocol.Context context = 6;
     if (cached_has_bits & 0x00000001u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
           *_impl_.context_);
     }
 
-    // optional .Environment environment = 7;
+    // optional .rsh.protocol.Environment environment = 7;
     if (cached_has_bits & 0x00000002u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
           *_impl_.environment_);
     }
 
-    // optional .Tier tier = 4;
+    // optional .rsh.protocol.Tier tier = 4;
     if (cached_has_bits & 0x00000004u) {
       total_size += 1 +
         ::_pbi::WireFormatLite::EnumSize(this->_internal_tier());
@@ -1746,23 +1760,23 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileRequest::GetClassData()
 void CompileRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<CompileRequest*>(&to_msg);
   auto& from = static_cast<const CompileRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:CompileRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.CompileRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   if (from._internal_has_function()) {
-    _this->_internal_mutable_function()->::Function::MergeFrom(
+    _this->_internal_mutable_function()->::rsh::protocol::Function::MergeFrom(
         from._internal_function());
   }
   cached_has_bits = from._impl_._has_bits_[0];
   if (cached_has_bits & 0x0000000fu) {
     if (cached_has_bits & 0x00000001u) {
-      _this->_internal_mutable_context()->::Context::MergeFrom(
+      _this->_internal_mutable_context()->::rsh::protocol::Context::MergeFrom(
           from._internal_context());
     }
     if (cached_has_bits & 0x00000002u) {
-      _this->_internal_mutable_environment()->::Environment::MergeFrom(
+      _this->_internal_mutable_environment()->::rsh::protocol::Environment::MergeFrom(
           from._internal_environment());
     }
     if (cached_has_bits & 0x00000004u) {
@@ -1777,7 +1791,7 @@ void CompileRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const :
 }
 
 void CompileRequest::CopyFrom(const CompileRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:CompileRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.CompileRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -1822,7 +1836,7 @@ CompileResponse::CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:CompileResponse)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.CompileResponse)
 }
 CompileResponse::CompileResponse(const CompileResponse& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -1861,7 +1875,7 @@ CompileResponse::CompileResponse(const CompileResponse& from)
       _this->GetArenaForAllocation());
   }
   _this->_impl_.tier_ = from._impl_.tier_;
-  // @@protoc_insertion_point(copy_constructor:CompileResponse)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.CompileResponse)
 }
 
 inline void CompileResponse::SharedCtor(
@@ -1891,7 +1905,7 @@ inline void CompileResponse::SharedCtor(
 }
 
 CompileResponse::~CompileResponse() {
-  // @@protoc_insertion_point(destructor:CompileResponse)
+  // @@protoc_insertion_point(destructor:rsh.protocol.CompileResponse)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -1911,7 +1925,7 @@ void CompileResponse::SetCachedSize(int size) const {
 }
 
 void CompileResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:CompileResponse)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.CompileResponse)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -1947,12 +1961,12 @@ const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContex
         } else
           goto handle_unusual;
         continue;
-      // .Tier tier = 2;
+      // .rsh.protocol.Tier tier = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
           uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
-          _internal_set_tier(static_cast<::Tier>(val));
+          _internal_set_tier(static_cast<::rsh::protocol::Tier>(val));
         } else
           goto handle_unusual;
         continue;
@@ -2000,7 +2014,7 @@ const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContex
 
 uint8_t* CompileResponse::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:CompileResponse)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.CompileResponse)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -2010,7 +2024,7 @@ uint8_t* CompileResponse::_InternalSerialize(
         1, this->_internal_hash(), target);
   }
 
-  // .Tier tier = 2;
+  // .rsh.protocol.Tier tier = 2;
   if (this->_internal_tier() != 0) {
     target = stream->EnsureSpace(target);
     target = ::_pbi::WireFormatLite::WriteEnumToArray(
@@ -2033,12 +2047,12 @@ uint8_t* CompileResponse::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:CompileResponse)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.CompileResponse)
   return target;
 }
 
 size_t CompileResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:CompileResponse)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.CompileResponse)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -2069,7 +2083,7 @@ size_t CompileResponse::ByteSizeLong() const {
     }
 
   }
-  // .Tier tier = 2;
+  // .rsh.protocol.Tier tier = 2;
   if (this->_internal_tier() != 0) {
     total_size += 1 +
       ::_pbi::WireFormatLite::EnumSize(this->_internal_tier());
@@ -2088,7 +2102,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileResponse::GetClassData(
 void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<CompileResponse*>(&to_msg);
   auto& from = static_cast<const CompileResponse&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:CompileResponse)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.CompileResponse)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -2112,7 +2126,7 @@ void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
 }
 
 void CompileResponse::CopyFrom(const CompileResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:CompileResponse)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.CompileResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -2163,7 +2177,7 @@ Function::Function(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:Function)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Function)
 }
 Function::Function(const Function& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -2209,7 +2223,7 @@ Function::Function(const Function& from)
     _this->_impl_.body_.Set(from._internal_body(), 
       _this->GetArenaForAllocation());
   }
-  // @@protoc_insertion_point(copy_constructor:Function)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Function)
 }
 
 inline void Function::SharedCtor(
@@ -2243,7 +2257,7 @@ inline void Function::SharedCtor(
 }
 
 Function::~Function() {
-  // @@protoc_insertion_point(destructor:Function)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Function)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -2264,7 +2278,7 @@ void Function::SetCachedSize(int size) const {
 }
 
 void Function::Clear() {
-// @@protoc_insertion_point(message_clear_start:Function)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Function)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -2302,7 +2316,7 @@ const char* Function::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
           auto str = _internal_mutable_name();
           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "Function.name"));
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.protocol.Function.name"));
         } else
           goto handle_unusual;
         continue;
@@ -2350,7 +2364,7 @@ const char* Function::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
 
 uint8_t* Function::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Function)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Function)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -2365,7 +2379,7 @@ uint8_t* Function::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "Function.name");
+      "rsh.protocol.Function.name");
     target = stream->WriteStringMaybeAliased(
         2, this->_internal_name(), target);
   }
@@ -2386,12 +2400,12 @@ uint8_t* Function::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Function)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Function)
   return target;
 }
 
 size_t Function::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Function)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Function)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -2440,7 +2454,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Function::GetClassData() const
 void Function::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Function*>(&to_msg);
   auto& from = static_cast<const Function&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Function)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Function)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -2461,7 +2475,7 @@ void Function::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTO
 }
 
 void Function::CopyFrom(const Function& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Function)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Function)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -2511,7 +2525,7 @@ FunctionRequest::FunctionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:FunctionRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.FunctionRequest)
 }
 FunctionRequest::FunctionRequest(const FunctionRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -2529,7 +2543,7 @@ FunctionRequest::FunctionRequest(const FunctionRequest& from)
     _this->_impl_.hash_.Set(from._internal_hash(), 
       _this->GetArenaForAllocation());
   }
-  // @@protoc_insertion_point(copy_constructor:FunctionRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.FunctionRequest)
 }
 
 inline void FunctionRequest::SharedCtor(
@@ -2547,7 +2561,7 @@ inline void FunctionRequest::SharedCtor(
 }
 
 FunctionRequest::~FunctionRequest() {
-  // @@protoc_insertion_point(destructor:FunctionRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.FunctionRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -2565,7 +2579,7 @@ void FunctionRequest::SetCachedSize(int size) const {
 }
 
 void FunctionRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:FunctionRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.FunctionRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -2614,7 +2628,7 @@ const char* FunctionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContex
 
 uint8_t* FunctionRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:FunctionRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.FunctionRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -2628,12 +2642,12 @@ uint8_t* FunctionRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:FunctionRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.FunctionRequest)
   return target;
 }
 
 size_t FunctionRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:FunctionRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.FunctionRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -2660,7 +2674,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionRequest::GetClassData(
 void FunctionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<FunctionRequest*>(&to_msg);
   auto& from = static_cast<const FunctionRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:FunctionRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.FunctionRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -2672,7 +2686,7 @@ void FunctionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
 }
 
 void FunctionRequest::CopyFrom(const FunctionRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:FunctionRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.FunctionRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -2726,7 +2740,7 @@ Environment::Environment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
   if (arena != nullptr && !is_message_owned) {
     arena->OwnCustomDestructor(this, &Environment::ArenaDtor);
   }
-  // @@protoc_insertion_point(arena_constructor:Environment)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Environment)
 }
 Environment::Environment(const Environment& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -2737,7 +2751,7 @@ Environment::Environment(const Environment& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   _this->_impl_.values_.MergeFrom(from._impl_.values_);
-  // @@protoc_insertion_point(copy_constructor:Environment)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Environment)
 }
 
 inline void Environment::SharedCtor(
@@ -2751,7 +2765,7 @@ inline void Environment::SharedCtor(
 }
 
 Environment::~Environment() {
-  // @@protoc_insertion_point(destructor:Environment)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Environment)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     ArenaDtor(this);
@@ -2775,7 +2789,7 @@ void Environment::SetCachedSize(int size) const {
 }
 
 void Environment::Clear() {
-// @@protoc_insertion_point(message_clear_start:Environment)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Environment)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -2828,7 +2842,7 @@ const char* Environment::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
 
 uint8_t* Environment::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Environment)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Environment)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -2842,7 +2856,7 @@ uint8_t* Environment::_InternalSerialize(
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
         entry.first.data(), static_cast<int>(entry.first.length()),
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-        "Environment.ValuesEntry.key");
+        "rsh.protocol.Environment.ValuesEntry.key");
     };
 
     if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
@@ -2862,12 +2876,12 @@ uint8_t* Environment::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Environment)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Environment)
   return target;
 }
 
 size_t Environment::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Environment)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Environment)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -2896,7 +2910,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Environment::GetClassData() co
 void Environment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Environment*>(&to_msg);
   auto& from = static_cast<const Environment&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Environment)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Environment)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -2906,7 +2920,7 @@ void Environment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR
 }
 
 void Environment::CopyFrom(const Environment& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Environment)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Environment)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -2938,7 +2952,7 @@ ValueRequest::ValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:ValueRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.ValueRequest)
 }
 ValueRequest::ValueRequest(const ValueRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -2948,7 +2962,7 @@ ValueRequest::ValueRequest(const ValueRequest& from)
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:ValueRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.ValueRequest)
 }
 
 inline void ValueRequest::SharedCtor(
@@ -2962,7 +2976,7 @@ inline void ValueRequest::SharedCtor(
 }
 
 ValueRequest::~ValueRequest() {
-  // @@protoc_insertion_point(destructor:ValueRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.ValueRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -2980,7 +2994,7 @@ void ValueRequest::SetCachedSize(int size) const {
 }
 
 void ValueRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:ValueRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.ValueRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -3034,7 +3048,7 @@ const char* ValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext*
 
 uint8_t* ValueRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:ValueRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.ValueRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -3048,12 +3062,12 @@ uint8_t* ValueRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:ValueRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.ValueRequest)
   return target;
 }
 
 size_t ValueRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:ValueRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.ValueRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -3081,7 +3095,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ValueRequest::GetClassData() c
 void ValueRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<ValueRequest*>(&to_msg);
   auto& from = static_cast<const ValueRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:ValueRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.ValueRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -3091,7 +3105,7 @@ void ValueRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::P
 }
 
 void ValueRequest::CopyFrom(const ValueRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:ValueRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.ValueRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -3123,7 +3137,7 @@ Value::Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:Value)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Value)
 }
 Value::Value(const Value& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -3150,7 +3164,7 @@ Value::Value(const Value& from)
     _this->_impl_.value_.Set(from._internal_value(), 
       _this->GetArenaForAllocation());
   }
-  // @@protoc_insertion_point(copy_constructor:Value)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Value)
 }
 
 inline void Value::SharedCtor(
@@ -3173,7 +3187,7 @@ inline void Value::SharedCtor(
 }
 
 Value::~Value() {
-  // @@protoc_insertion_point(destructor:Value)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Value)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -3192,7 +3206,7 @@ void Value::SetCachedSize(int size) const {
 }
 
 void Value::Clear() {
-// @@protoc_insertion_point(message_clear_start:Value)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Value)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -3251,7 +3265,7 @@ const char* Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 
 uint8_t* Value::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Value)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Value)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -3271,12 +3285,12 @@ uint8_t* Value::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Value)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Value)
   return target;
 }
 
 size_t Value::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Value)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Value)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -3310,7 +3324,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Value::GetClassData() const {
 void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Value*>(&to_msg);
   auto& from = static_cast<const Value&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Value)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Value)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -3325,7 +3339,7 @@ void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF
 }
 
 void Value::CopyFrom(const Value& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Value)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Value)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -3366,7 +3380,7 @@ Values::Values(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:Values)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Values)
 }
 Values::Values(const Values& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -3376,7 +3390,7 @@ Values::Values(const Values& from)
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:Values)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Values)
 }
 
 inline void Values::SharedCtor(
@@ -3390,7 +3404,7 @@ inline void Values::SharedCtor(
 }
 
 Values::~Values() {
-  // @@protoc_insertion_point(destructor:Values)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Values)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -3408,7 +3422,7 @@ void Values::SetCachedSize(int size) const {
 }
 
 void Values::Clear() {
-// @@protoc_insertion_point(message_clear_start:Values)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Values)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -3423,7 +3437,7 @@ const char* Values::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // repeated .Value values = 1;
+      // repeated .rsh.protocol.Value values = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr -= 1;
@@ -3461,11 +3475,11 @@ const char* Values::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
 
 uint8_t* Values::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Values)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Values)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // repeated .Value values = 1;
+  // repeated .rsh.protocol.Value values = 1;
   for (unsigned i = 0,
       n = static_cast<unsigned>(this->_internal_values_size()); i < n; i++) {
     const auto& repfield = this->_internal_values(i);
@@ -3477,19 +3491,19 @@ uint8_t* Values::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Values)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Values)
   return target;
 }
 
 size_t Values::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Values)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Values)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // repeated .Value values = 1;
+  // repeated .rsh.protocol.Value values = 1;
   total_size += 1UL * this->_internal_values_size();
   for (const auto& msg : this->_impl_.values_) {
     total_size +=
@@ -3509,7 +3523,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Values::GetClassData() const {
 void Values::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Values*>(&to_msg);
   auto& from = static_cast<const Values&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Values)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Values)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -3519,7 +3533,7 @@ void Values::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBU
 }
 
 void Values::CopyFrom(const Values& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Values)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Values)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -3550,13 +3564,13 @@ class Empty::_Internal {
 Empty::Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
-  // @@protoc_insertion_point(arena_constructor:Empty)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Empty)
 }
 Empty::Empty(const Empty& from)
   : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
   Empty* const _this = this; (void)_this;
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:Empty)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Empty)
 }
 
 
@@ -3591,7 +3605,7 @@ CallContext::CallContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:CallContext)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.CallContext)
 }
 CallContext::CallContext(const CallContext& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -3607,7 +3621,7 @@ CallContext::CallContext(const CallContext& from)
   ::memcpy(&_impl_.args_statically_matched_, &from._impl_.args_statically_matched_,
     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.no_missing_args_) -
     reinterpret_cast<char*>(&_impl_.args_statically_matched_)) + sizeof(_impl_.no_missing_args_));
-  // @@protoc_insertion_point(copy_constructor:CallContext)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.CallContext)
 }
 
 inline void CallContext::SharedCtor(
@@ -3624,7 +3638,7 @@ inline void CallContext::SharedCtor(
 }
 
 CallContext::~CallContext() {
-  // @@protoc_insertion_point(destructor:CallContext)
+  // @@protoc_insertion_point(destructor:rsh.protocol.CallContext)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -3641,7 +3655,7 @@ void CallContext::SetCachedSize(int size) const {
 }
 
 void CallContext::Clear() {
-// @@protoc_insertion_point(message_clear_start:CallContext)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.CallContext)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -3715,7 +3729,7 @@ const char* CallContext::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
 
 uint8_t* CallContext::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:CallContext)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.CallContext)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -3747,12 +3761,12 @@ uint8_t* CallContext::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:CallContext)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.CallContext)
   return target;
 }
 
 size_t CallContext::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:CallContext)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.CallContext)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -3792,7 +3806,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CallContext::GetClassData() co
 void CallContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<CallContext*>(&to_msg);
   auto& from = static_cast<const CallContext&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:CallContext)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.CallContext)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -3813,7 +3827,7 @@ void CallContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR
 }
 
 void CallContext::CopyFrom(const CallContext& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:CallContext)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.CallContext)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -3854,7 +3868,7 @@ ArgumentContext::ArgumentContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:ArgumentContext)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.ArgumentContext)
 }
 ArgumentContext::ArgumentContext(const ArgumentContext& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -3871,7 +3885,7 @@ ArgumentContext::ArgumentContext(const ArgumentContext& from)
   ::memcpy(&_impl_.eager_, &from._impl_.eager_,
     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
     reinterpret_cast<char*>(&_impl_.eager_)) + sizeof(_impl_.type_));
-  // @@protoc_insertion_point(copy_constructor:ArgumentContext)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.ArgumentContext)
 }
 
 inline void ArgumentContext::SharedCtor(
@@ -3889,7 +3903,7 @@ inline void ArgumentContext::SharedCtor(
 }
 
 ArgumentContext::~ArgumentContext() {
-  // @@protoc_insertion_point(destructor:ArgumentContext)
+  // @@protoc_insertion_point(destructor:rsh.protocol.ArgumentContext)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -3906,7 +3920,7 @@ void ArgumentContext::SetCachedSize(int size) const {
 }
 
 void ArgumentContext::Clear() {
-// @@protoc_insertion_point(message_clear_start:ArgumentContext)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.ArgumentContext)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -3950,12 +3964,12 @@ const char* ArgumentContext::_InternalParse(const char* ptr, ::_pbi::ParseContex
         } else
           goto handle_unusual;
         continue;
-      // optional .Type type = 4;
+      // optional .rsh.protocol.Type type = 4;
       case 4:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
           uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
-          _internal_set_type(static_cast<::Type>(val));
+          _internal_set_type(static_cast<::rsh::protocol::Type>(val));
         } else
           goto handle_unusual;
         continue;
@@ -3985,7 +3999,7 @@ const char* ArgumentContext::_InternalParse(const char* ptr, ::_pbi::ParseContex
 
 uint8_t* ArgumentContext::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:ArgumentContext)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.ArgumentContext)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -4007,7 +4021,7 @@ uint8_t* ArgumentContext::_InternalSerialize(
     target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_object(), target);
   }
 
-  // optional .Type type = 4;
+  // optional .rsh.protocol.Type type = 4;
   if (_internal_has_type()) {
     target = stream->EnsureSpace(target);
     target = ::_pbi::WireFormatLite::WriteEnumToArray(
@@ -4018,12 +4032,12 @@ uint8_t* ArgumentContext::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:ArgumentContext)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.ArgumentContext)
   return target;
 }
 
 size_t ArgumentContext::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:ArgumentContext)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.ArgumentContext)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -4045,7 +4059,7 @@ size_t ArgumentContext::ByteSizeLong() const {
     total_size += 1 + 1;
   }
 
-  // optional .Type type = 4;
+  // optional .rsh.protocol.Type type = 4;
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x00000001u) {
     total_size += 1 +
@@ -4065,7 +4079,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ArgumentContext::GetClassData(
 void ArgumentContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<ArgumentContext*>(&to_msg);
   auto& from = static_cast<const ArgumentContext&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:ArgumentContext)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.ArgumentContext)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -4086,7 +4100,7 @@ void ArgumentContext::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
 }
 
 void ArgumentContext::CopyFrom(const ArgumentContext& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:ArgumentContext)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.ArgumentContext)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -4118,10 +4132,10 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ArgumentContext::GetMetadata() const {
 
 class Context::_Internal {
  public:
-  static const ::CallContext& call_context(const Context* msg);
+  static const ::rsh::protocol::CallContext& call_context(const Context* msg);
 };
 
-const ::CallContext&
+const ::rsh::protocol::CallContext&
 Context::_Internal::call_context(const Context* msg) {
   return *msg->_impl_.call_context_;
 }
@@ -4129,7 +4143,7 @@ Context::Context(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:Context)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Context)
 }
 Context::Context(const Context& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -4141,9 +4155,9 @@ Context::Context(const Context& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   if (from._internal_has_call_context()) {
-    _this->_impl_.call_context_ = new ::CallContext(*from._impl_.call_context_);
+    _this->_impl_.call_context_ = new ::rsh::protocol::CallContext(*from._impl_.call_context_);
   }
-  // @@protoc_insertion_point(copy_constructor:Context)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Context)
 }
 
 inline void Context::SharedCtor(
@@ -4158,7 +4172,7 @@ inline void Context::SharedCtor(
 }
 
 Context::~Context() {
-  // @@protoc_insertion_point(destructor:Context)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Context)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -4177,7 +4191,7 @@ void Context::SetCachedSize(int size) const {
 }
 
 void Context::Clear() {
-// @@protoc_insertion_point(message_clear_start:Context)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Context)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -4196,7 +4210,7 @@ const char* Context::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .CallContext call_context = 1;
+      // .rsh.protocol.CallContext call_context = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr = ctx->ParseMessage(_internal_mutable_call_context(), ptr);
@@ -4204,7 +4218,7 @@ const char* Context::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
         } else
           goto handle_unusual;
         continue;
-      // repeated .ArgumentContext argument_context = 2;
+      // repeated .rsh.protocol.ArgumentContext argument_context = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr -= 1;
@@ -4242,18 +4256,18 @@ const char* Context::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
 
 uint8_t* Context::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Context)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Context)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .CallContext call_context = 1;
+  // .rsh.protocol.CallContext call_context = 1;
   if (this->_internal_has_call_context()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(1, _Internal::call_context(this),
         _Internal::call_context(this).GetCachedSize(), target, stream);
   }
 
-  // repeated .ArgumentContext argument_context = 2;
+  // repeated .rsh.protocol.ArgumentContext argument_context = 2;
   for (unsigned i = 0,
       n = static_cast<unsigned>(this->_internal_argument_context_size()); i < n; i++) {
     const auto& repfield = this->_internal_argument_context(i);
@@ -4265,26 +4279,26 @@ uint8_t* Context::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Context)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Context)
   return target;
 }
 
 size_t Context::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Context)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Context)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // repeated .ArgumentContext argument_context = 2;
+  // repeated .rsh.protocol.ArgumentContext argument_context = 2;
   total_size += 1UL * this->_internal_argument_context_size();
   for (const auto& msg : this->_impl_.argument_context_) {
     total_size +=
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
   }
 
-  // .CallContext call_context = 1;
+  // .rsh.protocol.CallContext call_context = 1;
   if (this->_internal_has_call_context()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -4304,21 +4318,21 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Context::GetClassData() const
 void Context::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Context*>(&to_msg);
   auto& from = static_cast<const Context&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Context)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Context)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   _this->_impl_.argument_context_.MergeFrom(from._impl_.argument_context_);
   if (from._internal_has_call_context()) {
-    _this->_internal_mutable_call_context()->::CallContext::MergeFrom(
+    _this->_internal_mutable_call_context()->::rsh::protocol::CallContext::MergeFrom(
         from._internal_call_context());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void Context::CopyFrom(const Context& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Context)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Context)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -4345,10 +4359,10 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Context::GetMetadata() const {
 
 class ContextRequest::_Internal {
  public:
-  static const ::Function& function(const ContextRequest* msg);
+  static const ::rsh::protocol::Function& function(const ContextRequest* msg);
 };
 
-const ::Function&
+const ::rsh::protocol::Function&
 ContextRequest::_Internal::function(const ContextRequest* msg) {
   return *msg->_impl_.function_;
 }
@@ -4356,7 +4370,7 @@ ContextRequest::ContextRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:ContextRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.ContextRequest)
 }
 ContextRequest::ContextRequest(const ContextRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -4367,9 +4381,9 @@ ContextRequest::ContextRequest(const ContextRequest& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   if (from._internal_has_function()) {
-    _this->_impl_.function_ = new ::Function(*from._impl_.function_);
+    _this->_impl_.function_ = new ::rsh::protocol::Function(*from._impl_.function_);
   }
-  // @@protoc_insertion_point(copy_constructor:ContextRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.ContextRequest)
 }
 
 inline void ContextRequest::SharedCtor(
@@ -4383,7 +4397,7 @@ inline void ContextRequest::SharedCtor(
 }
 
 ContextRequest::~ContextRequest() {
-  // @@protoc_insertion_point(destructor:ContextRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.ContextRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -4401,7 +4415,7 @@ void ContextRequest::SetCachedSize(int size) const {
 }
 
 void ContextRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:ContextRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.ContextRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -4419,7 +4433,7 @@ const char* ContextRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .Function function = 1;
+      // .rsh.protocol.Function function = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr = ctx->ParseMessage(_internal_mutable_function(), ptr);
@@ -4452,11 +4466,11 @@ const char* ContextRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
 
 uint8_t* ContextRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:ContextRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.ContextRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .Function function = 1;
+  // .rsh.protocol.Function function = 1;
   if (this->_internal_has_function()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(1, _Internal::function(this),
@@ -4467,19 +4481,19 @@ uint8_t* ContextRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:ContextRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.ContextRequest)
   return target;
 }
 
 size_t ContextRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:ContextRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.ContextRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // .Function function = 1;
+  // .rsh.protocol.Function function = 1;
   if (this->_internal_has_function()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -4499,20 +4513,20 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextRequest::GetClassData()
 void ContextRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<ContextRequest*>(&to_msg);
   auto& from = static_cast<const ContextRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:ContextRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.ContextRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   if (from._internal_has_function()) {
-    _this->_internal_mutable_function()->::Function::MergeFrom(
+    _this->_internal_mutable_function()->::rsh::protocol::Function::MergeFrom(
         from._internal_function());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void ContextRequest::CopyFrom(const ContextRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:ContextRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.ContextRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -4544,7 +4558,7 @@ TestFeedback::TestFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:TestFeedback)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.TestFeedback)
 }
 TestFeedback::TestFeedback(const TestFeedback& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -4555,7 +4569,7 @@ TestFeedback::TestFeedback(const TestFeedback& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   _this->_impl_.test_lattice_ = from._impl_.test_lattice_;
-  // @@protoc_insertion_point(copy_constructor:TestFeedback)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.TestFeedback)
 }
 
 inline void TestFeedback::SharedCtor(
@@ -4569,7 +4583,7 @@ inline void TestFeedback::SharedCtor(
 }
 
 TestFeedback::~TestFeedback() {
-  // @@protoc_insertion_point(destructor:TestFeedback)
+  // @@protoc_insertion_point(destructor:rsh.protocol.TestFeedback)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -4586,7 +4600,7 @@ void TestFeedback::SetCachedSize(int size) const {
 }
 
 void TestFeedback::Clear() {
-// @@protoc_insertion_point(message_clear_start:TestFeedback)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.TestFeedback)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -4601,12 +4615,12 @@ const char* TestFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .TestLattice test_lattice = 1;
+      // .rsh.protocol.TestLattice test_lattice = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
           uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
-          _internal_set_test_lattice(static_cast<::TestLattice>(val));
+          _internal_set_test_lattice(static_cast<::rsh::protocol::TestLattice>(val));
         } else
           goto handle_unusual;
         continue;
@@ -4635,11 +4649,11 @@ const char* TestFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
 
 uint8_t* TestFeedback::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:TestFeedback)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.TestFeedback)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .TestLattice test_lattice = 1;
+  // .rsh.protocol.TestLattice test_lattice = 1;
   if (this->_internal_test_lattice() != 0) {
     target = stream->EnsureSpace(target);
     target = ::_pbi::WireFormatLite::WriteEnumToArray(
@@ -4650,19 +4664,19 @@ uint8_t* TestFeedback::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:TestFeedback)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.TestFeedback)
   return target;
 }
 
 size_t TestFeedback::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:TestFeedback)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.TestFeedback)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // .TestLattice test_lattice = 1;
+  // .rsh.protocol.TestLattice test_lattice = 1;
   if (this->_internal_test_lattice() != 0) {
     total_size += 1 +
       ::_pbi::WireFormatLite::EnumSize(this->_internal_test_lattice());
@@ -4681,7 +4695,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TestFeedback::GetClassData() c
 void TestFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<TestFeedback*>(&to_msg);
   auto& from = static_cast<const TestFeedback&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:TestFeedback)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.TestFeedback)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -4693,7 +4707,7 @@ void TestFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::P
 }
 
 void TestFeedback::CopyFrom(const TestFeedback& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:TestFeedback)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.TestFeedback)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -4725,7 +4739,7 @@ CallFeedback::CallFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:CallFeedback)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.CallFeedback)
 }
 CallFeedback::CallFeedback(const CallFeedback& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -4745,7 +4759,7 @@ CallFeedback::CallFeedback(const CallFeedback& from)
       _this->GetArenaForAllocation());
   }
   _this->_impl_.n_calls_ = from._impl_.n_calls_;
-  // @@protoc_insertion_point(copy_constructor:CallFeedback)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.CallFeedback)
 }
 
 inline void CallFeedback::SharedCtor(
@@ -4764,7 +4778,7 @@ inline void CallFeedback::SharedCtor(
 }
 
 CallFeedback::~CallFeedback() {
-  // @@protoc_insertion_point(destructor:CallFeedback)
+  // @@protoc_insertion_point(destructor:rsh.protocol.CallFeedback)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -4782,7 +4796,7 @@ void CallFeedback::SetCachedSize(int size) const {
 }
 
 void CallFeedback::Clear() {
-// @@protoc_insertion_point(message_clear_start:CallFeedback)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.CallFeedback)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -4840,7 +4854,7 @@ const char* CallFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
 
 uint8_t* CallFeedback::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:CallFeedback)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.CallFeedback)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -4860,12 +4874,12 @@ uint8_t* CallFeedback::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:CallFeedback)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.CallFeedback)
   return target;
 }
 
 size_t CallFeedback::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:CallFeedback)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.CallFeedback)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -4897,7 +4911,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CallFeedback::GetClassData() c
 void CallFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<CallFeedback*>(&to_msg);
   auto& from = static_cast<const CallFeedback&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:CallFeedback)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.CallFeedback)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -4912,7 +4926,7 @@ void CallFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::P
 }
 
 void CallFeedback::CopyFrom(const CallFeedback& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:CallFeedback)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.CallFeedback)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -4950,7 +4964,7 @@ ValueFeedback::ValueFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:ValueFeedback)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.ValueFeedback)
 }
 ValueFeedback::ValueFeedback(const ValueFeedback& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -4967,7 +4981,7 @@ ValueFeedback::ValueFeedback(const ValueFeedback& from)
   ::memcpy(&_impl_.scalar_, &from._impl_.scalar_,
     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_promise_) -
     reinterpret_cast<char*>(&_impl_.scalar_)) + sizeof(_impl_.is_promise_));
-  // @@protoc_insertion_point(copy_constructor:ValueFeedback)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.ValueFeedback)
 }
 
 inline void ValueFeedback::SharedCtor(
@@ -4985,7 +4999,7 @@ inline void ValueFeedback::SharedCtor(
 }
 
 ValueFeedback::~ValueFeedback() {
-  // @@protoc_insertion_point(destructor:ValueFeedback)
+  // @@protoc_insertion_point(destructor:rsh.protocol.ValueFeedback)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -5002,7 +5016,7 @@ void ValueFeedback::SetCachedSize(int size) const {
 }
 
 void ValueFeedback::Clear() {
-// @@protoc_insertion_point(message_clear_start:ValueFeedback)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.ValueFeedback)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -5084,7 +5098,7 @@ const char* ValueFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
 
 uint8_t* ValueFeedback::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:ValueFeedback)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.ValueFeedback)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -5122,12 +5136,12 @@ uint8_t* ValueFeedback::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:ValueFeedback)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.ValueFeedback)
   return target;
 }
 
 size_t ValueFeedback::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:ValueFeedback)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.ValueFeedback)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -5172,7 +5186,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ValueFeedback::GetClassData()
 void ValueFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<ValueFeedback*>(&to_msg);
   auto& from = static_cast<const ValueFeedback&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:ValueFeedback)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.ValueFeedback)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -5196,7 +5210,7 @@ void ValueFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::
 }
 
 void ValueFeedback::CopyFrom(const ValueFeedback& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:ValueFeedback)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.ValueFeedback)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -5227,24 +5241,24 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ValueFeedback::GetMetadata() const {
 
 class TypeFeedback_Feedback::_Internal {
  public:
-  static const ::TestFeedback& test_feedback(const TypeFeedback_Feedback* msg);
-  static const ::CallFeedback& call_feedback(const TypeFeedback_Feedback* msg);
-  static const ::ValueFeedback& value_feedback(const TypeFeedback_Feedback* msg);
+  static const ::rsh::protocol::TestFeedback& test_feedback(const TypeFeedback_Feedback* msg);
+  static const ::rsh::protocol::CallFeedback& call_feedback(const TypeFeedback_Feedback* msg);
+  static const ::rsh::protocol::ValueFeedback& value_feedback(const TypeFeedback_Feedback* msg);
 };
 
-const ::TestFeedback&
+const ::rsh::protocol::TestFeedback&
 TypeFeedback_Feedback::_Internal::test_feedback(const TypeFeedback_Feedback* msg) {
   return *msg->_impl_.feedback_.test_feedback_;
 }
-const ::CallFeedback&
+const ::rsh::protocol::CallFeedback&
 TypeFeedback_Feedback::_Internal::call_feedback(const TypeFeedback_Feedback* msg) {
   return *msg->_impl_.feedback_.call_feedback_;
 }
-const ::ValueFeedback&
+const ::rsh::protocol::ValueFeedback&
 TypeFeedback_Feedback::_Internal::value_feedback(const TypeFeedback_Feedback* msg) {
   return *msg->_impl_.feedback_.value_feedback_;
 }
-void TypeFeedback_Feedback::set_allocated_test_feedback(::TestFeedback* test_feedback) {
+void TypeFeedback_Feedback::set_allocated_test_feedback(::rsh::protocol::TestFeedback* test_feedback) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   clear_feedback();
   if (test_feedback) {
@@ -5257,9 +5271,9 @@ void TypeFeedback_Feedback::set_allocated_test_feedback(::TestFeedback* test_fee
     set_has_test_feedback();
     _impl_.feedback_.test_feedback_ = test_feedback;
   }
-  // @@protoc_insertion_point(field_set_allocated:TypeFeedback.Feedback.test_feedback)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.TypeFeedback.Feedback.test_feedback)
 }
-void TypeFeedback_Feedback::set_allocated_call_feedback(::CallFeedback* call_feedback) {
+void TypeFeedback_Feedback::set_allocated_call_feedback(::rsh::protocol::CallFeedback* call_feedback) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   clear_feedback();
   if (call_feedback) {
@@ -5272,9 +5286,9 @@ void TypeFeedback_Feedback::set_allocated_call_feedback(::CallFeedback* call_fee
     set_has_call_feedback();
     _impl_.feedback_.call_feedback_ = call_feedback;
   }
-  // @@protoc_insertion_point(field_set_allocated:TypeFeedback.Feedback.call_feedback)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.TypeFeedback.Feedback.call_feedback)
 }
-void TypeFeedback_Feedback::set_allocated_value_feedback(::ValueFeedback* value_feedback) {
+void TypeFeedback_Feedback::set_allocated_value_feedback(::rsh::protocol::ValueFeedback* value_feedback) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   clear_feedback();
   if (value_feedback) {
@@ -5287,13 +5301,13 @@ void TypeFeedback_Feedback::set_allocated_value_feedback(::ValueFeedback* value_
     set_has_value_feedback();
     _impl_.feedback_.value_feedback_ = value_feedback;
   }
-  // @@protoc_insertion_point(field_set_allocated:TypeFeedback.Feedback.value_feedback)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.TypeFeedback.Feedback.value_feedback)
 }
 TypeFeedback_Feedback::TypeFeedback_Feedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.TypeFeedback.Feedback)
 }
 TypeFeedback_Feedback::TypeFeedback_Feedback(const TypeFeedback_Feedback& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -5307,17 +5321,17 @@ TypeFeedback_Feedback::TypeFeedback_Feedback(const TypeFeedback_Feedback& from)
   clear_has_feedback();
   switch (from.feedback_case()) {
     case kTestFeedback: {
-      _this->_internal_mutable_test_feedback()->::TestFeedback::MergeFrom(
+      _this->_internal_mutable_test_feedback()->::rsh::protocol::TestFeedback::MergeFrom(
           from._internal_test_feedback());
       break;
     }
     case kCallFeedback: {
-      _this->_internal_mutable_call_feedback()->::CallFeedback::MergeFrom(
+      _this->_internal_mutable_call_feedback()->::rsh::protocol::CallFeedback::MergeFrom(
           from._internal_call_feedback());
       break;
     }
     case kValueFeedback: {
-      _this->_internal_mutable_value_feedback()->::ValueFeedback::MergeFrom(
+      _this->_internal_mutable_value_feedback()->::rsh::protocol::ValueFeedback::MergeFrom(
           from._internal_value_feedback());
       break;
     }
@@ -5325,7 +5339,7 @@ TypeFeedback_Feedback::TypeFeedback_Feedback(const TypeFeedback_Feedback& from)
       break;
     }
   }
-  // @@protoc_insertion_point(copy_constructor:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.TypeFeedback.Feedback)
 }
 
 inline void TypeFeedback_Feedback::SharedCtor(
@@ -5341,7 +5355,7 @@ inline void TypeFeedback_Feedback::SharedCtor(
 }
 
 TypeFeedback_Feedback::~TypeFeedback_Feedback() {
-  // @@protoc_insertion_point(destructor:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(destructor:rsh.protocol.TypeFeedback.Feedback)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -5361,7 +5375,7 @@ void TypeFeedback_Feedback::SetCachedSize(int size) const {
 }
 
 void TypeFeedback_Feedback::clear_feedback() {
-// @@protoc_insertion_point(one_of_clear_start:TypeFeedback.Feedback)
+// @@protoc_insertion_point(one_of_clear_start:rsh.protocol.TypeFeedback.Feedback)
   switch (feedback_case()) {
     case kTestFeedback: {
       if (GetArenaForAllocation() == nullptr) {
@@ -5390,7 +5404,7 @@ void TypeFeedback_Feedback::clear_feedback() {
 
 
 void TypeFeedback_Feedback::Clear() {
-// @@protoc_insertion_point(message_clear_start:TypeFeedback.Feedback)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.TypeFeedback.Feedback)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -5405,7 +5419,7 @@ const char* TypeFeedback_Feedback::_InternalParse(const char* ptr, ::_pbi::Parse
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .TestFeedback test_feedback = 1;
+      // .rsh.protocol.TestFeedback test_feedback = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr = ctx->ParseMessage(_internal_mutable_test_feedback(), ptr);
@@ -5413,7 +5427,7 @@ const char* TypeFeedback_Feedback::_InternalParse(const char* ptr, ::_pbi::Parse
         } else
           goto handle_unusual;
         continue;
-      // .CallFeedback call_feedback = 2;
+      // .rsh.protocol.CallFeedback call_feedback = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr = ctx->ParseMessage(_internal_mutable_call_feedback(), ptr);
@@ -5421,7 +5435,7 @@ const char* TypeFeedback_Feedback::_InternalParse(const char* ptr, ::_pbi::Parse
         } else
           goto handle_unusual;
         continue;
-      // .ValueFeedback value_feedback = 3;
+      // .rsh.protocol.ValueFeedback value_feedback = 3;
       case 3:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
           ptr = ctx->ParseMessage(_internal_mutable_value_feedback(), ptr);
@@ -5454,25 +5468,25 @@ const char* TypeFeedback_Feedback::_InternalParse(const char* ptr, ::_pbi::Parse
 
 uint8_t* TypeFeedback_Feedback::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.TypeFeedback.Feedback)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .TestFeedback test_feedback = 1;
+  // .rsh.protocol.TestFeedback test_feedback = 1;
   if (_internal_has_test_feedback()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(1, _Internal::test_feedback(this),
         _Internal::test_feedback(this).GetCachedSize(), target, stream);
   }
 
-  // .CallFeedback call_feedback = 2;
+  // .rsh.protocol.CallFeedback call_feedback = 2;
   if (_internal_has_call_feedback()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(2, _Internal::call_feedback(this),
         _Internal::call_feedback(this).GetCachedSize(), target, stream);
   }
 
-  // .ValueFeedback value_feedback = 3;
+  // .rsh.protocol.ValueFeedback value_feedback = 3;
   if (_internal_has_value_feedback()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(3, _Internal::value_feedback(this),
@@ -5483,12 +5497,12 @@ uint8_t* TypeFeedback_Feedback::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.TypeFeedback.Feedback)
   return target;
 }
 
 size_t TypeFeedback_Feedback::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:TypeFeedback.Feedback)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.TypeFeedback.Feedback)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -5496,21 +5510,21 @@ size_t TypeFeedback_Feedback::ByteSizeLong() const {
   (void) cached_has_bits;
 
   switch (feedback_case()) {
-    // .TestFeedback test_feedback = 1;
+    // .rsh.protocol.TestFeedback test_feedback = 1;
     case kTestFeedback: {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
           *_impl_.feedback_.test_feedback_);
       break;
     }
-    // .CallFeedback call_feedback = 2;
+    // .rsh.protocol.CallFeedback call_feedback = 2;
     case kCallFeedback: {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
           *_impl_.feedback_.call_feedback_);
       break;
     }
-    // .ValueFeedback value_feedback = 3;
+    // .rsh.protocol.ValueFeedback value_feedback = 3;
     case kValueFeedback: {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -5534,24 +5548,24 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TypeFeedback_Feedback::GetClas
 void TypeFeedback_Feedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<TypeFeedback_Feedback*>(&to_msg);
   auto& from = static_cast<const TypeFeedback_Feedback&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.TypeFeedback.Feedback)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   switch (from.feedback_case()) {
     case kTestFeedback: {
-      _this->_internal_mutable_test_feedback()->::TestFeedback::MergeFrom(
+      _this->_internal_mutable_test_feedback()->::rsh::protocol::TestFeedback::MergeFrom(
           from._internal_test_feedback());
       break;
     }
     case kCallFeedback: {
-      _this->_internal_mutable_call_feedback()->::CallFeedback::MergeFrom(
+      _this->_internal_mutable_call_feedback()->::rsh::protocol::CallFeedback::MergeFrom(
           from._internal_call_feedback());
       break;
     }
     case kValueFeedback: {
-      _this->_internal_mutable_value_feedback()->::ValueFeedback::MergeFrom(
+      _this->_internal_mutable_value_feedback()->::rsh::protocol::ValueFeedback::MergeFrom(
           from._internal_value_feedback());
       break;
     }
@@ -5563,7 +5577,7 @@ void TypeFeedback_Feedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg,
 }
 
 void TypeFeedback_Feedback::CopyFrom(const TypeFeedback_Feedback& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:TypeFeedback.Feedback)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.TypeFeedback.Feedback)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -5613,7 +5627,7 @@ TypeFeedback::TypeFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
   if (arena != nullptr && !is_message_owned) {
     arena->OwnCustomDestructor(this, &TypeFeedback::ArenaDtor);
   }
-  // @@protoc_insertion_point(arena_constructor:TypeFeedback)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.TypeFeedback)
 }
 TypeFeedback::TypeFeedback(const TypeFeedback& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -5624,7 +5638,7 @@ TypeFeedback::TypeFeedback(const TypeFeedback& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   _this->_impl_.types_.MergeFrom(from._impl_.types_);
-  // @@protoc_insertion_point(copy_constructor:TypeFeedback)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.TypeFeedback)
 }
 
 inline void TypeFeedback::SharedCtor(
@@ -5638,7 +5652,7 @@ inline void TypeFeedback::SharedCtor(
 }
 
 TypeFeedback::~TypeFeedback() {
-  // @@protoc_insertion_point(destructor:TypeFeedback)
+  // @@protoc_insertion_point(destructor:rsh.protocol.TypeFeedback)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     ArenaDtor(this);
@@ -5662,7 +5676,7 @@ void TypeFeedback::SetCachedSize(int size) const {
 }
 
 void TypeFeedback::Clear() {
-// @@protoc_insertion_point(message_clear_start:TypeFeedback)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.TypeFeedback)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -5677,7 +5691,7 @@ const char* TypeFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // map<int64, .TypeFeedback.Feedback> types = 2;
+      // map<int64, .rsh.protocol.TypeFeedback.Feedback> types = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr -= 1;
@@ -5715,13 +5729,13 @@ const char* TypeFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
 
 uint8_t* TypeFeedback::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:TypeFeedback)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.TypeFeedback)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // map<int64, .TypeFeedback.Feedback> types = 2;
+  // map<int64, .rsh.protocol.TypeFeedback.Feedback> types = 2;
   if (!this->_internal_types().empty()) {
-    using MapType = ::_pb::Map<int64_t, ::TypeFeedback_Feedback>;
+    using MapType = ::_pb::Map<int64_t, ::rsh::protocol::TypeFeedback_Feedback>;
     using WireHelper = TypeFeedback_TypesEntry_DoNotUse::Funcs;
     const auto& map_field = this->_internal_types();
 
@@ -5740,22 +5754,22 @@ uint8_t* TypeFeedback::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:TypeFeedback)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.TypeFeedback)
   return target;
 }
 
 size_t TypeFeedback::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:TypeFeedback)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.TypeFeedback)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // map<int64, .TypeFeedback.Feedback> types = 2;
+  // map<int64, .rsh.protocol.TypeFeedback.Feedback> types = 2;
   total_size += 1 *
       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_types_size());
-  for (::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >::const_iterator
+  for (::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >::const_iterator
       it = this->_internal_types().begin();
       it != this->_internal_types().end(); ++it) {
     total_size += TypeFeedback_TypesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
@@ -5774,7 +5788,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TypeFeedback::GetClassData() c
 void TypeFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<TypeFeedback*>(&to_msg);
   auto& from = static_cast<const TypeFeedback&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:TypeFeedback)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.TypeFeedback)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -5784,7 +5798,7 @@ void TypeFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::P
 }
 
 void TypeFeedback::CopyFrom(const TypeFeedback& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:TypeFeedback)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.TypeFeedback)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -5810,10 +5824,10 @@ ::PROTOBUF_NAMESPACE_ID::Metadata TypeFeedback::GetMetadata() const {
 
 class FeedbackRequest::_Internal {
  public:
-  static const ::Function& function(const FeedbackRequest* msg);
+  static const ::rsh::protocol::Function& function(const FeedbackRequest* msg);
 };
 
-const ::Function&
+const ::rsh::protocol::Function&
 FeedbackRequest::_Internal::function(const FeedbackRequest* msg) {
   return *msg->_impl_.function_;
 }
@@ -5821,7 +5835,7 @@ FeedbackRequest::FeedbackRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:FeedbackRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.FeedbackRequest)
 }
 FeedbackRequest::FeedbackRequest(const FeedbackRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -5832,9 +5846,9 @@ FeedbackRequest::FeedbackRequest(const FeedbackRequest& from)
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
   if (from._internal_has_function()) {
-    _this->_impl_.function_ = new ::Function(*from._impl_.function_);
+    _this->_impl_.function_ = new ::rsh::protocol::Function(*from._impl_.function_);
   }
-  // @@protoc_insertion_point(copy_constructor:FeedbackRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.FeedbackRequest)
 }
 
 inline void FeedbackRequest::SharedCtor(
@@ -5848,7 +5862,7 @@ inline void FeedbackRequest::SharedCtor(
 }
 
 FeedbackRequest::~FeedbackRequest() {
-  // @@protoc_insertion_point(destructor:FeedbackRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.FeedbackRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -5866,7 +5880,7 @@ void FeedbackRequest::SetCachedSize(int size) const {
 }
 
 void FeedbackRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:FeedbackRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.FeedbackRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -5884,7 +5898,7 @@ const char* FeedbackRequest::_InternalParse(const char* ptr, ::_pbi::ParseContex
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // .Function function = 1;
+      // .rsh.protocol.Function function = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr = ctx->ParseMessage(_internal_mutable_function(), ptr);
@@ -5917,11 +5931,11 @@ const char* FeedbackRequest::_InternalParse(const char* ptr, ::_pbi::ParseContex
 
 uint8_t* FeedbackRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:FeedbackRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.FeedbackRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .Function function = 1;
+  // .rsh.protocol.Function function = 1;
   if (this->_internal_has_function()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(1, _Internal::function(this),
@@ -5932,19 +5946,19 @@ uint8_t* FeedbackRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:FeedbackRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.FeedbackRequest)
   return target;
 }
 
 size_t FeedbackRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:FeedbackRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.FeedbackRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // .Function function = 1;
+  // .rsh.protocol.Function function = 1;
   if (this->_internal_has_function()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -5964,20 +5978,20 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FeedbackRequest::GetClassData(
 void FeedbackRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<FeedbackRequest*>(&to_msg);
   auto& from = static_cast<const FeedbackRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:FeedbackRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.FeedbackRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
   if (from._internal_has_function()) {
-    _this->_internal_mutable_function()->::Function::MergeFrom(
+    _this->_internal_mutable_function()->::rsh::protocol::Function::MergeFrom(
         from._internal_function());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void FeedbackRequest::CopyFrom(const FeedbackRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:FeedbackRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.FeedbackRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -6009,7 +6023,7 @@ PackageSource::PackageSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:PackageSource)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.PackageSource)
 }
 PackageSource::PackageSource(const PackageSource& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -6034,7 +6048,7 @@ PackageSource::PackageSource(const PackageSource& from)
       break;
     }
   }
-  // @@protoc_insertion_point(copy_constructor:PackageSource)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.PackageSource)
 }
 
 inline void PackageSource::SharedCtor(
@@ -6050,7 +6064,7 @@ inline void PackageSource::SharedCtor(
 }
 
 PackageSource::~PackageSource() {
-  // @@protoc_insertion_point(destructor:PackageSource)
+  // @@protoc_insertion_point(destructor:rsh.protocol.PackageSource)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -6070,7 +6084,7 @@ void PackageSource::SetCachedSize(int size) const {
 }
 
 void PackageSource::clear_source() {
-// @@protoc_insertion_point(one_of_clear_start:PackageSource)
+// @@protoc_insertion_point(one_of_clear_start:rsh.protocol.PackageSource)
   switch (source_case()) {
     case kRMirror: {
       _impl_.source_.r_mirror_.Destroy();
@@ -6089,7 +6103,7 @@ void PackageSource::clear_source() {
 
 
 void PackageSource::Clear() {
-// @@protoc_insertion_point(message_clear_start:PackageSource)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.PackageSource)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -6110,7 +6124,7 @@ const char* PackageSource::_InternalParse(const char* ptr, ::_pbi::ParseContext*
           auto str = _internal_mutable_r_mirror();
           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "PackageSource.r_mirror"));
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.protocol.PackageSource.r_mirror"));
         } else
           goto handle_unusual;
         continue;
@@ -6120,7 +6134,7 @@ const char* PackageSource::_InternalParse(const char* ptr, ::_pbi::ParseContext*
           auto str = _internal_mutable_github_url();
           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "PackageSource.github_url"));
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.protocol.PackageSource.github_url"));
         } else
           goto handle_unusual;
         continue;
@@ -6149,7 +6163,7 @@ const char* PackageSource::_InternalParse(const char* ptr, ::_pbi::ParseContext*
 
 uint8_t* PackageSource::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:PackageSource)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.PackageSource)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -6158,7 +6172,7 @@ uint8_t* PackageSource::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_r_mirror().data(), static_cast<int>(this->_internal_r_mirror().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "PackageSource.r_mirror");
+      "rsh.protocol.PackageSource.r_mirror");
     target = stream->WriteStringMaybeAliased(
         2, this->_internal_r_mirror(), target);
   }
@@ -6168,7 +6182,7 @@ uint8_t* PackageSource::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_github_url().data(), static_cast<int>(this->_internal_github_url().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "PackageSource.github_url");
+      "rsh.protocol.PackageSource.github_url");
     target = stream->WriteStringMaybeAliased(
         3, this->_internal_github_url(), target);
   }
@@ -6177,12 +6191,12 @@ uint8_t* PackageSource::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:PackageSource)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.PackageSource)
   return target;
 }
 
 size_t PackageSource::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:PackageSource)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.PackageSource)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -6221,7 +6235,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PackageSource::GetClassData()
 void PackageSource::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<PackageSource*>(&to_msg);
   auto& from = static_cast<const PackageSource&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:PackageSource)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.PackageSource)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -6243,7 +6257,7 @@ void PackageSource::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::
 }
 
 void PackageSource::CopyFrom(const PackageSource& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:PackageSource)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.PackageSource)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -6271,18 +6285,18 @@ ::PROTOBUF_NAMESPACE_ID::Metadata PackageSource::GetMetadata() const {
 class Package::_Internal {
  public:
   using HasBits = decltype(std::declval<Package>()._impl_._has_bits_);
-  static const ::Version& version(const Package* msg);
-  static const ::PackageSource& source(const Package* msg);
+  static const ::rsh::protocol::Version& version(const Package* msg);
+  static const ::rsh::protocol::PackageSource& source(const Package* msg);
   static void set_has_source(HasBits* has_bits) {
     (*has_bits)[0] |= 1u;
   }
 };
 
-const ::Version&
+const ::rsh::protocol::Version&
 Package::_Internal::version(const Package* msg) {
   return *msg->_impl_.version_;
 }
-const ::PackageSource&
+const ::rsh::protocol::PackageSource&
 Package::_Internal::source(const Package* msg) {
   return *msg->_impl_.source_;
 }
@@ -6290,7 +6304,7 @@ Package::Package(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:Package)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.Package)
 }
 Package::Package(const Package& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -6313,12 +6327,12 @@ Package::Package(const Package& from)
       _this->GetArenaForAllocation());
   }
   if (from._internal_has_version()) {
-    _this->_impl_.version_ = new ::Version(*from._impl_.version_);
+    _this->_impl_.version_ = new ::rsh::protocol::Version(*from._impl_.version_);
   }
   if (from._internal_has_source()) {
-    _this->_impl_.source_ = new ::PackageSource(*from._impl_.source_);
+    _this->_impl_.source_ = new ::rsh::protocol::PackageSource(*from._impl_.source_);
   }
-  // @@protoc_insertion_point(copy_constructor:Package)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.Package)
 }
 
 inline void Package::SharedCtor(
@@ -6340,7 +6354,7 @@ inline void Package::SharedCtor(
 }
 
 Package::~Package() {
-  // @@protoc_insertion_point(destructor:Package)
+  // @@protoc_insertion_point(destructor:rsh.protocol.Package)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -6361,7 +6375,7 @@ void Package::SetCachedSize(int size) const {
 }
 
 void Package::Clear() {
-// @@protoc_insertion_point(message_clear_start:Package)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.Package)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -6394,11 +6408,11 @@ const char* Package::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
           auto str = _internal_mutable_name();
           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "Package.name"));
+          CHK_(::_pbi::VerifyUTF8(str, "rsh.protocol.Package.name"));
         } else
           goto handle_unusual;
         continue;
-      // .Version version = 2;
+      // .rsh.protocol.Version version = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
           ptr = ctx->ParseMessage(_internal_mutable_version(), ptr);
@@ -6420,7 +6434,7 @@ const char* Package::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
         } else
           goto handle_unusual;
         continue;
-      // optional .PackageSource source = 5;
+      // optional .rsh.protocol.PackageSource source = 5;
       case 5:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
           ptr = ctx->ParseMessage(_internal_mutable_source(), ptr);
@@ -6454,7 +6468,7 @@ const char* Package::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
 
 uint8_t* Package::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:Package)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.Package)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -6463,12 +6477,12 @@ uint8_t* Package::_InternalSerialize(
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
       this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "Package.name");
+      "rsh.protocol.Package.name");
     target = stream->WriteStringMaybeAliased(
         1, this->_internal_name(), target);
   }
 
-  // .Version version = 2;
+  // .rsh.protocol.Version version = 2;
   if (this->_internal_has_version()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(2, _Internal::version(this),
@@ -6481,7 +6495,7 @@ uint8_t* Package::_InternalSerialize(
     target = stream->WriteBytes(4, s, target);
   }
 
-  // optional .PackageSource source = 5;
+  // optional .rsh.protocol.PackageSource source = 5;
   if (_internal_has_source()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(5, _Internal::source(this),
@@ -6492,12 +6506,12 @@ uint8_t* Package::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:Package)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.Package)
   return target;
 }
 
 size_t Package::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:Package)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.Package)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -6519,14 +6533,14 @@ size_t Package::ByteSizeLong() const {
         this->_internal_name());
   }
 
-  // .Version version = 2;
+  // .rsh.protocol.Version version = 2;
   if (this->_internal_has_version()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
         *_impl_.version_);
   }
 
-  // optional .PackageSource source = 5;
+  // optional .rsh.protocol.PackageSource source = 5;
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x00000001u) {
     total_size += 1 +
@@ -6547,7 +6561,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Package::GetClassData() const
 void Package::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<Package*>(&to_msg);
   auto& from = static_cast<const Package&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:Package)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.Package)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -6557,18 +6571,18 @@ void Package::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOB
     _this->_internal_set_name(from._internal_name());
   }
   if (from._internal_has_version()) {
-    _this->_internal_mutable_version()->::Version::MergeFrom(
+    _this->_internal_mutable_version()->::rsh::protocol::Version::MergeFrom(
         from._internal_version());
   }
   if (from._internal_has_source()) {
-    _this->_internal_mutable_source()->::PackageSource::MergeFrom(
+    _this->_internal_mutable_source()->::rsh::protocol::PackageSource::MergeFrom(
         from._internal_source());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
 void Package::CopyFrom(const Package& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:Package)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.Package)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -6613,7 +6627,7 @@ PackageRequest::PackageRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                          bool is_message_owned)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
   SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:PackageRequest)
+  // @@protoc_insertion_point(arena_constructor:rsh.protocol.PackageRequest)
 }
 PackageRequest::PackageRequest(const PackageRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
@@ -6631,7 +6645,7 @@ PackageRequest::PackageRequest(const PackageRequest& from)
     _this->_impl_.hash_.Set(from._internal_hash(), 
       _this->GetArenaForAllocation());
   }
-  // @@protoc_insertion_point(copy_constructor:PackageRequest)
+  // @@protoc_insertion_point(copy_constructor:rsh.protocol.PackageRequest)
 }
 
 inline void PackageRequest::SharedCtor(
@@ -6649,7 +6663,7 @@ inline void PackageRequest::SharedCtor(
 }
 
 PackageRequest::~PackageRequest() {
-  // @@protoc_insertion_point(destructor:PackageRequest)
+  // @@protoc_insertion_point(destructor:rsh.protocol.PackageRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -6667,7 +6681,7 @@ void PackageRequest::SetCachedSize(int size) const {
 }
 
 void PackageRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:PackageRequest)
+// @@protoc_insertion_point(message_clear_start:rsh.protocol.PackageRequest)
   uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
@@ -6716,7 +6730,7 @@ const char* PackageRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
 
 uint8_t* PackageRequest::_InternalSerialize(
     uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:PackageRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:rsh.protocol.PackageRequest)
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
@@ -6730,12 +6744,12 @@ uint8_t* PackageRequest::_InternalSerialize(
     target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:PackageRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:rsh.protocol.PackageRequest)
   return target;
 }
 
 size_t PackageRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:PackageRequest)
+// @@protoc_insertion_point(message_byte_size_start:rsh.protocol.PackageRequest)
   size_t total_size = 0;
 
   uint32_t cached_has_bits = 0;
@@ -6762,7 +6776,7 @@ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PackageRequest::GetClassData()
 void PackageRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
   auto* const _this = static_cast<PackageRequest*>(&to_msg);
   auto& from = static_cast<const PackageRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:PackageRequest)
+  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.protocol.PackageRequest)
   GOOGLE_DCHECK_NE(&from, _this);
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
@@ -6774,7 +6788,7 @@ void PackageRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const :
 }
 
 void PackageRequest::CopyFrom(const PackageRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:PackageRequest)
+// @@protoc_insertion_point(class_specific_copy_from_start:rsh.protocol.PackageRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -6802,114 +6816,116 @@ ::PROTOBUF_NAMESPACE_ID::Metadata PackageRequest::GetMetadata() const {
 }
 
 // @@protoc_insertion_point(namespace_scope)
+}  // namespace protocol
+}  // namespace rsh
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::Version*
-Arena::CreateMaybeMessage< ::Version >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Version >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Version*
+Arena::CreateMaybeMessage< ::rsh::protocol::Version >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Version >(arena);
 }
-template<> PROTOBUF_NOINLINE ::InitRequest*
-Arena::CreateMaybeMessage< ::InitRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::InitRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::InitRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::InitRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::InitRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::InitResponse*
-Arena::CreateMaybeMessage< ::InitResponse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::InitResponse >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::InitResponse*
+Arena::CreateMaybeMessage< ::rsh::protocol::InitResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::InitResponse >(arena);
 }
-template<> PROTOBUF_NOINLINE ::CompileRequest*
-Arena::CreateMaybeMessage< ::CompileRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::CompileRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::CompileRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::CompileRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::CompileRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::CompileResponse*
-Arena::CreateMaybeMessage< ::CompileResponse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::CompileResponse >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::CompileResponse*
+Arena::CreateMaybeMessage< ::rsh::protocol::CompileResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::CompileResponse >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Function*
-Arena::CreateMaybeMessage< ::Function >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Function >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Function*
+Arena::CreateMaybeMessage< ::rsh::protocol::Function >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Function >(arena);
 }
-template<> PROTOBUF_NOINLINE ::FunctionRequest*
-Arena::CreateMaybeMessage< ::FunctionRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::FunctionRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::FunctionRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::FunctionRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::FunctionRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Environment_ValuesEntry_DoNotUse*
-Arena::CreateMaybeMessage< ::Environment_ValuesEntry_DoNotUse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Environment_ValuesEntry_DoNotUse >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Environment_ValuesEntry_DoNotUse*
+Arena::CreateMaybeMessage< ::rsh::protocol::Environment_ValuesEntry_DoNotUse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Environment_ValuesEntry_DoNotUse >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Environment*
-Arena::CreateMaybeMessage< ::Environment >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Environment >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Environment*
+Arena::CreateMaybeMessage< ::rsh::protocol::Environment >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Environment >(arena);
 }
-template<> PROTOBUF_NOINLINE ::ValueRequest*
-Arena::CreateMaybeMessage< ::ValueRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::ValueRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::ValueRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::ValueRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::ValueRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Value*
-Arena::CreateMaybeMessage< ::Value >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Value >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Value*
+Arena::CreateMaybeMessage< ::rsh::protocol::Value >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Value >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Values*
-Arena::CreateMaybeMessage< ::Values >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Values >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Values*
+Arena::CreateMaybeMessage< ::rsh::protocol::Values >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Values >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Empty*
-Arena::CreateMaybeMessage< ::Empty >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Empty >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Empty*
+Arena::CreateMaybeMessage< ::rsh::protocol::Empty >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Empty >(arena);
 }
-template<> PROTOBUF_NOINLINE ::CallContext*
-Arena::CreateMaybeMessage< ::CallContext >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::CallContext >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::CallContext*
+Arena::CreateMaybeMessage< ::rsh::protocol::CallContext >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::CallContext >(arena);
 }
-template<> PROTOBUF_NOINLINE ::ArgumentContext*
-Arena::CreateMaybeMessage< ::ArgumentContext >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::ArgumentContext >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::ArgumentContext*
+Arena::CreateMaybeMessage< ::rsh::protocol::ArgumentContext >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::ArgumentContext >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Context*
-Arena::CreateMaybeMessage< ::Context >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Context >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Context*
+Arena::CreateMaybeMessage< ::rsh::protocol::Context >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Context >(arena);
 }
-template<> PROTOBUF_NOINLINE ::ContextRequest*
-Arena::CreateMaybeMessage< ::ContextRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::ContextRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::ContextRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::ContextRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::ContextRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::TestFeedback*
-Arena::CreateMaybeMessage< ::TestFeedback >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::TestFeedback >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::TestFeedback*
+Arena::CreateMaybeMessage< ::rsh::protocol::TestFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::TestFeedback >(arena);
 }
-template<> PROTOBUF_NOINLINE ::CallFeedback*
-Arena::CreateMaybeMessage< ::CallFeedback >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::CallFeedback >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::CallFeedback*
+Arena::CreateMaybeMessage< ::rsh::protocol::CallFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::CallFeedback >(arena);
 }
-template<> PROTOBUF_NOINLINE ::ValueFeedback*
-Arena::CreateMaybeMessage< ::ValueFeedback >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::ValueFeedback >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::ValueFeedback*
+Arena::CreateMaybeMessage< ::rsh::protocol::ValueFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::ValueFeedback >(arena);
 }
-template<> PROTOBUF_NOINLINE ::TypeFeedback_Feedback*
-Arena::CreateMaybeMessage< ::TypeFeedback_Feedback >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::TypeFeedback_Feedback >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::TypeFeedback_Feedback*
+Arena::CreateMaybeMessage< ::rsh::protocol::TypeFeedback_Feedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::TypeFeedback_Feedback >(arena);
 }
-template<> PROTOBUF_NOINLINE ::TypeFeedback_TypesEntry_DoNotUse*
-Arena::CreateMaybeMessage< ::TypeFeedback_TypesEntry_DoNotUse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::TypeFeedback_TypesEntry_DoNotUse >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse*
+Arena::CreateMaybeMessage< ::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse >(arena);
 }
-template<> PROTOBUF_NOINLINE ::TypeFeedback*
-Arena::CreateMaybeMessage< ::TypeFeedback >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::TypeFeedback >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::TypeFeedback*
+Arena::CreateMaybeMessage< ::rsh::protocol::TypeFeedback >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::TypeFeedback >(arena);
 }
-template<> PROTOBUF_NOINLINE ::FeedbackRequest*
-Arena::CreateMaybeMessage< ::FeedbackRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::FeedbackRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::FeedbackRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::FeedbackRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::FeedbackRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::PackageSource*
-Arena::CreateMaybeMessage< ::PackageSource >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::PackageSource >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::PackageSource*
+Arena::CreateMaybeMessage< ::rsh::protocol::PackageSource >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::PackageSource >(arena);
 }
-template<> PROTOBUF_NOINLINE ::Package*
-Arena::CreateMaybeMessage< ::Package >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::Package >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::Package*
+Arena::CreateMaybeMessage< ::rsh::protocol::Package >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::Package >(arena);
 }
-template<> PROTOBUF_NOINLINE ::PackageRequest*
-Arena::CreateMaybeMessage< ::PackageRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::PackageRequest >(arena);
+template<> PROTOBUF_NOINLINE ::rsh::protocol::PackageRequest*
+Arena::CreateMaybeMessage< ::rsh::protocol::PackageRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::rsh::protocol::PackageRequest >(arena);
 }
 PROTOBUF_NAMESPACE_CLOSE
 
diff --git a/client/rsh/src/messages.pb.h b/client/rsh/src/messages.pb.h
index b28d96991..3f8caf8b4 100644
--- a/client/rsh/src/messages.pb.h
+++ b/client/rsh/src/messages.pb.h
@@ -49,6 +49,8 @@ struct TableStruct_messages_2eproto {
   static const uint32_t offsets[];
 };
 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2eproto;
+namespace rsh {
+namespace protocol {
 class ArgumentContext;
 struct ArgumentContextDefaultTypeInternal;
 extern ArgumentContextDefaultTypeInternal _ArgumentContext_default_instance_;
@@ -130,35 +132,39 @@ extern ValuesDefaultTypeInternal _Values_default_instance_;
 class Version;
 struct VersionDefaultTypeInternal;
 extern VersionDefaultTypeInternal _Version_default_instance_;
+}  // namespace protocol
+}  // namespace rsh
 PROTOBUF_NAMESPACE_OPEN
-template<> ::ArgumentContext* Arena::CreateMaybeMessage<::ArgumentContext>(Arena*);
-template<> ::CallContext* Arena::CreateMaybeMessage<::CallContext>(Arena*);
-template<> ::CallFeedback* Arena::CreateMaybeMessage<::CallFeedback>(Arena*);
-template<> ::CompileRequest* Arena::CreateMaybeMessage<::CompileRequest>(Arena*);
-template<> ::CompileResponse* Arena::CreateMaybeMessage<::CompileResponse>(Arena*);
-template<> ::Context* Arena::CreateMaybeMessage<::Context>(Arena*);
-template<> ::ContextRequest* Arena::CreateMaybeMessage<::ContextRequest>(Arena*);
-template<> ::Empty* Arena::CreateMaybeMessage<::Empty>(Arena*);
-template<> ::Environment* Arena::CreateMaybeMessage<::Environment>(Arena*);
-template<> ::Environment_ValuesEntry_DoNotUse* Arena::CreateMaybeMessage<::Environment_ValuesEntry_DoNotUse>(Arena*);
-template<> ::FeedbackRequest* Arena::CreateMaybeMessage<::FeedbackRequest>(Arena*);
-template<> ::Function* Arena::CreateMaybeMessage<::Function>(Arena*);
-template<> ::FunctionRequest* Arena::CreateMaybeMessage<::FunctionRequest>(Arena*);
-template<> ::InitRequest* Arena::CreateMaybeMessage<::InitRequest>(Arena*);
-template<> ::InitResponse* Arena::CreateMaybeMessage<::InitResponse>(Arena*);
-template<> ::Package* Arena::CreateMaybeMessage<::Package>(Arena*);
-template<> ::PackageRequest* Arena::CreateMaybeMessage<::PackageRequest>(Arena*);
-template<> ::PackageSource* Arena::CreateMaybeMessage<::PackageSource>(Arena*);
-template<> ::TestFeedback* Arena::CreateMaybeMessage<::TestFeedback>(Arena*);
-template<> ::TypeFeedback* Arena::CreateMaybeMessage<::TypeFeedback>(Arena*);
-template<> ::TypeFeedback_Feedback* Arena::CreateMaybeMessage<::TypeFeedback_Feedback>(Arena*);
-template<> ::TypeFeedback_TypesEntry_DoNotUse* Arena::CreateMaybeMessage<::TypeFeedback_TypesEntry_DoNotUse>(Arena*);
-template<> ::Value* Arena::CreateMaybeMessage<::Value>(Arena*);
-template<> ::ValueFeedback* Arena::CreateMaybeMessage<::ValueFeedback>(Arena*);
-template<> ::ValueRequest* Arena::CreateMaybeMessage<::ValueRequest>(Arena*);
-template<> ::Values* Arena::CreateMaybeMessage<::Values>(Arena*);
-template<> ::Version* Arena::CreateMaybeMessage<::Version>(Arena*);
+template<> ::rsh::protocol::ArgumentContext* Arena::CreateMaybeMessage<::rsh::protocol::ArgumentContext>(Arena*);
+template<> ::rsh::protocol::CallContext* Arena::CreateMaybeMessage<::rsh::protocol::CallContext>(Arena*);
+template<> ::rsh::protocol::CallFeedback* Arena::CreateMaybeMessage<::rsh::protocol::CallFeedback>(Arena*);
+template<> ::rsh::protocol::CompileRequest* Arena::CreateMaybeMessage<::rsh::protocol::CompileRequest>(Arena*);
+template<> ::rsh::protocol::CompileResponse* Arena::CreateMaybeMessage<::rsh::protocol::CompileResponse>(Arena*);
+template<> ::rsh::protocol::Context* Arena::CreateMaybeMessage<::rsh::protocol::Context>(Arena*);
+template<> ::rsh::protocol::ContextRequest* Arena::CreateMaybeMessage<::rsh::protocol::ContextRequest>(Arena*);
+template<> ::rsh::protocol::Empty* Arena::CreateMaybeMessage<::rsh::protocol::Empty>(Arena*);
+template<> ::rsh::protocol::Environment* Arena::CreateMaybeMessage<::rsh::protocol::Environment>(Arena*);
+template<> ::rsh::protocol::Environment_ValuesEntry_DoNotUse* Arena::CreateMaybeMessage<::rsh::protocol::Environment_ValuesEntry_DoNotUse>(Arena*);
+template<> ::rsh::protocol::FeedbackRequest* Arena::CreateMaybeMessage<::rsh::protocol::FeedbackRequest>(Arena*);
+template<> ::rsh::protocol::Function* Arena::CreateMaybeMessage<::rsh::protocol::Function>(Arena*);
+template<> ::rsh::protocol::FunctionRequest* Arena::CreateMaybeMessage<::rsh::protocol::FunctionRequest>(Arena*);
+template<> ::rsh::protocol::InitRequest* Arena::CreateMaybeMessage<::rsh::protocol::InitRequest>(Arena*);
+template<> ::rsh::protocol::InitResponse* Arena::CreateMaybeMessage<::rsh::protocol::InitResponse>(Arena*);
+template<> ::rsh::protocol::Package* Arena::CreateMaybeMessage<::rsh::protocol::Package>(Arena*);
+template<> ::rsh::protocol::PackageRequest* Arena::CreateMaybeMessage<::rsh::protocol::PackageRequest>(Arena*);
+template<> ::rsh::protocol::PackageSource* Arena::CreateMaybeMessage<::rsh::protocol::PackageSource>(Arena*);
+template<> ::rsh::protocol::TestFeedback* Arena::CreateMaybeMessage<::rsh::protocol::TestFeedback>(Arena*);
+template<> ::rsh::protocol::TypeFeedback* Arena::CreateMaybeMessage<::rsh::protocol::TypeFeedback>(Arena*);
+template<> ::rsh::protocol::TypeFeedback_Feedback* Arena::CreateMaybeMessage<::rsh::protocol::TypeFeedback_Feedback>(Arena*);
+template<> ::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse* Arena::CreateMaybeMessage<::rsh::protocol::TypeFeedback_TypesEntry_DoNotUse>(Arena*);
+template<> ::rsh::protocol::Value* Arena::CreateMaybeMessage<::rsh::protocol::Value>(Arena*);
+template<> ::rsh::protocol::ValueFeedback* Arena::CreateMaybeMessage<::rsh::protocol::ValueFeedback>(Arena*);
+template<> ::rsh::protocol::ValueRequest* Arena::CreateMaybeMessage<::rsh::protocol::ValueRequest>(Arena*);
+template<> ::rsh::protocol::Values* Arena::CreateMaybeMessage<::rsh::protocol::Values>(Arena*);
+template<> ::rsh::protocol::Version* Arena::CreateMaybeMessage<::rsh::protocol::Version>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
+namespace rsh {
+namespace protocol {
 
 enum Tier : int {
   BASELINE = 0,
@@ -241,7 +247,7 @@ inline bool Type_Parse(
 // ===================================================================
 
 class Version final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Version) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Version) */ {
  public:
   inline Version() : Version(nullptr) {}
   ~Version() override;
@@ -344,7 +350,7 @@ class Version final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Version";
+    return "rsh.protocol.Version";
   }
   protected:
   explicit Version(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -392,7 +398,7 @@ class Version final :
   void _internal_set_patch(int32_t value);
   public:
 
-  // @@protoc_insertion_point(class_scope:Version)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Version)
  private:
   class _Internal;
 
@@ -411,7 +417,7 @@ class Version final :
 // -------------------------------------------------------------------
 
 class InitRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:InitRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.InitRequest) */ {
  public:
   inline InitRequest() : InitRequest(nullptr) {}
   ~InitRequest() override;
@@ -514,7 +520,7 @@ class InitRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "InitRequest";
+    return "rsh.protocol.InitRequest";
   }
   protected:
   explicit InitRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -574,43 +580,43 @@ class InitRequest final :
   std::string* _internal_mutable_platform();
   public:
 
-  // .Version Rsh_version = 1;
+  // .rsh.protocol.Version Rsh_version = 1;
   bool has_rsh_version() const;
   private:
   bool _internal_has_rsh_version() const;
   public:
   void clear_rsh_version();
-  const ::Version& rsh_version() const;
-  PROTOBUF_NODISCARD ::Version* release_rsh_version();
-  ::Version* mutable_rsh_version();
-  void set_allocated_rsh_version(::Version* rsh_version);
+  const ::rsh::protocol::Version& rsh_version() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Version* release_rsh_version();
+  ::rsh::protocol::Version* mutable_rsh_version();
+  void set_allocated_rsh_version(::rsh::protocol::Version* rsh_version);
   private:
-  const ::Version& _internal_rsh_version() const;
-  ::Version* _internal_mutable_rsh_version();
+  const ::rsh::protocol::Version& _internal_rsh_version() const;
+  ::rsh::protocol::Version* _internal_mutable_rsh_version();
   public:
   void unsafe_arena_set_allocated_rsh_version(
-      ::Version* rsh_version);
-  ::Version* unsafe_arena_release_rsh_version();
+      ::rsh::protocol::Version* rsh_version);
+  ::rsh::protocol::Version* unsafe_arena_release_rsh_version();
 
-  // .Version R_version = 2;
+  // .rsh.protocol.Version R_version = 2;
   bool has_r_version() const;
   private:
   bool _internal_has_r_version() const;
   public:
   void clear_r_version();
-  const ::Version& r_version() const;
-  PROTOBUF_NODISCARD ::Version* release_r_version();
-  ::Version* mutable_r_version();
-  void set_allocated_r_version(::Version* r_version);
+  const ::rsh::protocol::Version& r_version() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Version* release_r_version();
+  ::rsh::protocol::Version* mutable_r_version();
+  void set_allocated_r_version(::rsh::protocol::Version* r_version);
   private:
-  const ::Version& _internal_r_version() const;
-  ::Version* _internal_mutable_r_version();
+  const ::rsh::protocol::Version& _internal_r_version() const;
+  ::rsh::protocol::Version* _internal_mutable_r_version();
   public:
   void unsafe_arena_set_allocated_r_version(
-      ::Version* r_version);
-  ::Version* unsafe_arena_release_r_version();
+      ::rsh::protocol::Version* r_version);
+  ::rsh::protocol::Version* unsafe_arena_release_r_version();
 
-  // @@protoc_insertion_point(class_scope:InitRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.InitRequest)
  private:
   class _Internal;
 
@@ -620,8 +626,8 @@ class InitRequest final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> package_hash_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
-    ::Version* rsh_version_;
-    ::Version* r_version_;
+    ::rsh::protocol::Version* rsh_version_;
+    ::rsh::protocol::Version* r_version_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -630,7 +636,7 @@ class InitRequest final :
 // -------------------------------------------------------------------
 
 class InitResponse final :
-    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:InitResponse) */ {
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:rsh.protocol.InitResponse) */ {
  public:
   inline InitResponse() : InitResponse(nullptr) {}
   explicit PROTOBUF_CONSTEXPR InitResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
@@ -718,7 +724,7 @@ class InitResponse final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "InitResponse";
+    return "rsh.protocol.InitResponse";
   }
   protected:
   explicit InitResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -734,7 +740,7 @@ class InitResponse final :
 
   // accessors -------------------------------------------------------
 
-  // @@protoc_insertion_point(class_scope:InitResponse)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.InitResponse)
  private:
   class _Internal;
 
@@ -748,7 +754,7 @@ class InitResponse final :
 // -------------------------------------------------------------------
 
 class CompileRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CompileRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.CompileRequest) */ {
  public:
   inline CompileRequest() : CompileRequest(nullptr) {}
   ~CompileRequest() override;
@@ -851,7 +857,7 @@ class CompileRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "CompileRequest";
+    return "rsh.protocol.CompileRequest";
   }
   protected:
   explicit CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -874,71 +880,71 @@ class CompileRequest final :
     kTierFieldNumber = 4,
     kOptimizationLevelFieldNumber = 5,
   };
-  // .Function function = 2;
+  // .rsh.protocol.Function function = 2;
   bool has_function() const;
   private:
   bool _internal_has_function() const;
   public:
   void clear_function();
-  const ::Function& function() const;
-  PROTOBUF_NODISCARD ::Function* release_function();
-  ::Function* mutable_function();
-  void set_allocated_function(::Function* function);
+  const ::rsh::protocol::Function& function() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Function* release_function();
+  ::rsh::protocol::Function* mutable_function();
+  void set_allocated_function(::rsh::protocol::Function* function);
   private:
-  const ::Function& _internal_function() const;
-  ::Function* _internal_mutable_function();
+  const ::rsh::protocol::Function& _internal_function() const;
+  ::rsh::protocol::Function* _internal_mutable_function();
   public:
   void unsafe_arena_set_allocated_function(
-      ::Function* function);
-  ::Function* unsafe_arena_release_function();
+      ::rsh::protocol::Function* function);
+  ::rsh::protocol::Function* unsafe_arena_release_function();
 
-  // optional .Context context = 6;
+  // optional .rsh.protocol.Context context = 6;
   bool has_context() const;
   private:
   bool _internal_has_context() const;
   public:
   void clear_context();
-  const ::Context& context() const;
-  PROTOBUF_NODISCARD ::Context* release_context();
-  ::Context* mutable_context();
-  void set_allocated_context(::Context* context);
+  const ::rsh::protocol::Context& context() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Context* release_context();
+  ::rsh::protocol::Context* mutable_context();
+  void set_allocated_context(::rsh::protocol::Context* context);
   private:
-  const ::Context& _internal_context() const;
-  ::Context* _internal_mutable_context();
+  const ::rsh::protocol::Context& _internal_context() const;
+  ::rsh::protocol::Context* _internal_mutable_context();
   public:
   void unsafe_arena_set_allocated_context(
-      ::Context* context);
-  ::Context* unsafe_arena_release_context();
+      ::rsh::protocol::Context* context);
+  ::rsh::protocol::Context* unsafe_arena_release_context();
 
-  // optional .Environment environment = 7;
+  // optional .rsh.protocol.Environment environment = 7;
   bool has_environment() const;
   private:
   bool _internal_has_environment() const;
   public:
   void clear_environment();
-  const ::Environment& environment() const;
-  PROTOBUF_NODISCARD ::Environment* release_environment();
-  ::Environment* mutable_environment();
-  void set_allocated_environment(::Environment* environment);
+  const ::rsh::protocol::Environment& environment() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Environment* release_environment();
+  ::rsh::protocol::Environment* mutable_environment();
+  void set_allocated_environment(::rsh::protocol::Environment* environment);
   private:
-  const ::Environment& _internal_environment() const;
-  ::Environment* _internal_mutable_environment();
+  const ::rsh::protocol::Environment& _internal_environment() const;
+  ::rsh::protocol::Environment* _internal_mutable_environment();
   public:
   void unsafe_arena_set_allocated_environment(
-      ::Environment* environment);
-  ::Environment* unsafe_arena_release_environment();
+      ::rsh::protocol::Environment* environment);
+  ::rsh::protocol::Environment* unsafe_arena_release_environment();
 
-  // optional .Tier tier = 4;
+  // optional .rsh.protocol.Tier tier = 4;
   bool has_tier() const;
   private:
   bool _internal_has_tier() const;
   public:
   void clear_tier();
-  ::Tier tier() const;
-  void set_tier(::Tier value);
+  ::rsh::protocol::Tier tier() const;
+  void set_tier(::rsh::protocol::Tier value);
   private:
-  ::Tier _internal_tier() const;
-  void _internal_set_tier(::Tier value);
+  ::rsh::protocol::Tier _internal_tier() const;
+  void _internal_set_tier(::rsh::protocol::Tier value);
   public:
 
   // optional int32 optimization_level = 5;
@@ -954,7 +960,7 @@ class CompileRequest final :
   void _internal_set_optimization_level(int32_t value);
   public:
 
-  // @@protoc_insertion_point(class_scope:CompileRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.CompileRequest)
  private:
   class _Internal;
 
@@ -964,9 +970,9 @@ class CompileRequest final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::Function* function_;
-    ::Context* context_;
-    ::Environment* environment_;
+    ::rsh::protocol::Function* function_;
+    ::rsh::protocol::Context* context_;
+    ::rsh::protocol::Environment* environment_;
     int tier_;
     int32_t optimization_level_;
   };
@@ -976,7 +982,7 @@ class CompileRequest final :
 // -------------------------------------------------------------------
 
 class CompileResponse final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CompileResponse) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.CompileResponse) */ {
  public:
   inline CompileResponse() : CompileResponse(nullptr) {}
   ~CompileResponse() override;
@@ -1079,7 +1085,7 @@ class CompileResponse final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "CompileResponse";
+    return "rsh.protocol.CompileResponse";
   }
   protected:
   explicit CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -1151,16 +1157,16 @@ class CompileResponse final :
   std::string* _internal_mutable_constant_pool();
   public:
 
-  // .Tier tier = 2;
+  // .rsh.protocol.Tier tier = 2;
   void clear_tier();
-  ::Tier tier() const;
-  void set_tier(::Tier value);
+  ::rsh::protocol::Tier tier() const;
+  void set_tier(::rsh::protocol::Tier value);
   private:
-  ::Tier _internal_tier() const;
-  void _internal_set_tier(::Tier value);
+  ::rsh::protocol::Tier _internal_tier() const;
+  void _internal_set_tier(::rsh::protocol::Tier value);
   public:
 
-  // @@protoc_insertion_point(class_scope:CompileResponse)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.CompileResponse)
  private:
   class _Internal;
 
@@ -1181,7 +1187,7 @@ class CompileResponse final :
 // -------------------------------------------------------------------
 
 class Function final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Function) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Function) */ {
  public:
   inline Function() : Function(nullptr) {}
   ~Function() override;
@@ -1284,7 +1290,7 @@ class Function final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Function";
+    return "rsh.protocol.Function";
   }
   protected:
   explicit Function(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -1366,7 +1372,7 @@ class Function final :
   std::string* _internal_mutable_body();
   public:
 
-  // @@protoc_insertion_point(class_scope:Function)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Function)
  private:
   class _Internal;
 
@@ -1387,7 +1393,7 @@ class Function final :
 // -------------------------------------------------------------------
 
 class FunctionRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:FunctionRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.FunctionRequest) */ {
  public:
   inline FunctionRequest() : FunctionRequest(nullptr) {}
   ~FunctionRequest() override;
@@ -1490,7 +1496,7 @@ class FunctionRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "FunctionRequest";
+    return "rsh.protocol.FunctionRequest";
   }
   protected:
   explicit FunctionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -1523,7 +1529,7 @@ class FunctionRequest final :
   std::string* _internal_mutable_hash();
   public:
 
-  // @@protoc_insertion_point(class_scope:FunctionRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.FunctionRequest)
  private:
   class _Internal;
 
@@ -1555,7 +1561,7 @@ class Environment_ValuesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::interna
   void MergeFrom(const Environment_ValuesEntry_DoNotUse& other);
   static const Environment_ValuesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Environment_ValuesEntry_DoNotUse*>(&_Environment_ValuesEntry_DoNotUse_default_instance_); }
   static bool ValidateKey(std::string* s) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "Environment.ValuesEntry.key");
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "rsh.protocol.Environment.ValuesEntry.key");
  }
   static bool ValidateValue(void*) { return true; }
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
@@ -1566,7 +1572,7 @@ class Environment_ValuesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::interna
 // -------------------------------------------------------------------
 
 class Environment final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Environment) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Environment) */ {
  public:
   inline Environment() : Environment(nullptr) {}
   ~Environment() override;
@@ -1669,7 +1675,7 @@ class Environment final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Environment";
+    return "rsh.protocol.Environment";
   }
   protected:
   explicit Environment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -1708,7 +1714,7 @@ class Environment final :
   ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
       mutable_values();
 
-  // @@protoc_insertion_point(class_scope:Environment)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Environment)
  private:
   class _Internal;
 
@@ -1729,7 +1735,7 @@ class Environment final :
 // -------------------------------------------------------------------
 
 class ValueRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ValueRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.ValueRequest) */ {
  public:
   inline ValueRequest() : ValueRequest(nullptr) {}
   ~ValueRequest() override;
@@ -1832,7 +1838,7 @@ class ValueRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "ValueRequest";
+    return "rsh.protocol.ValueRequest";
   }
   protected:
   explicit ValueRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -1875,7 +1881,7 @@ class ValueRequest final :
   std::string* _internal_add_hash();
   public:
 
-  // @@protoc_insertion_point(class_scope:ValueRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.ValueRequest)
  private:
   class _Internal;
 
@@ -1892,7 +1898,7 @@ class ValueRequest final :
 // -------------------------------------------------------------------
 
 class Value final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Value) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Value) */ {
  public:
   inline Value() : Value(nullptr) {}
   ~Value() override;
@@ -1995,7 +2001,7 @@ class Value final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Value";
+    return "rsh.protocol.Value";
   }
   protected:
   explicit Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -2043,7 +2049,7 @@ class Value final :
   std::string* _internal_mutable_value();
   public:
 
-  // @@protoc_insertion_point(class_scope:Value)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Value)
  private:
   class _Internal;
 
@@ -2061,7 +2067,7 @@ class Value final :
 // -------------------------------------------------------------------
 
 class Values final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Values) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Values) */ {
  public:
   inline Values() : Values(nullptr) {}
   ~Values() override;
@@ -2164,7 +2170,7 @@ class Values final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Values";
+    return "rsh.protocol.Values";
   }
   protected:
   explicit Values(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -2183,25 +2189,25 @@ class Values final :
   enum : int {
     kValuesFieldNumber = 1,
   };
-  // repeated .Value values = 1;
+  // repeated .rsh.protocol.Value values = 1;
   int values_size() const;
   private:
   int _internal_values_size() const;
   public:
   void clear_values();
-  ::Value* mutable_values(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >*
+  ::rsh::protocol::Value* mutable_values(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::Value >*
       mutable_values();
   private:
-  const ::Value& _internal_values(int index) const;
-  ::Value* _internal_add_values();
+  const ::rsh::protocol::Value& _internal_values(int index) const;
+  ::rsh::protocol::Value* _internal_add_values();
   public:
-  const ::Value& values(int index) const;
-  ::Value* add_values();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >&
+  const ::rsh::protocol::Value& values(int index) const;
+  ::rsh::protocol::Value* add_values();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::Value >&
       values() const;
 
-  // @@protoc_insertion_point(class_scope:Values)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Values)
  private:
   class _Internal;
 
@@ -2209,7 +2215,7 @@ class Values final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value > values_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::Value > values_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -2218,7 +2224,7 @@ class Values final :
 // -------------------------------------------------------------------
 
 class Empty final :
-    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:Empty) */ {
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:rsh.protocol.Empty) */ {
  public:
   inline Empty() : Empty(nullptr) {}
   explicit PROTOBUF_CONSTEXPR Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
@@ -2306,7 +2312,7 @@ class Empty final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Empty";
+    return "rsh.protocol.Empty";
   }
   protected:
   explicit Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -2322,7 +2328,7 @@ class Empty final :
 
   // accessors -------------------------------------------------------
 
-  // @@protoc_insertion_point(class_scope:Empty)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Empty)
  private:
   class _Internal;
 
@@ -2336,7 +2342,7 @@ class Empty final :
 // -------------------------------------------------------------------
 
 class CallContext final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CallContext) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.CallContext) */ {
  public:
   inline CallContext() : CallContext(nullptr) {}
   ~CallContext() override;
@@ -2439,7 +2445,7 @@ class CallContext final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "CallContext";
+    return "rsh.protocol.CallContext";
   }
   protected:
   explicit CallContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -2497,7 +2503,7 @@ class CallContext final :
   void _internal_set_no_missing_args(bool value);
   public:
 
-  // @@protoc_insertion_point(class_scope:CallContext)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.CallContext)
  private:
   class _Internal;
 
@@ -2517,7 +2523,7 @@ class CallContext final :
 // -------------------------------------------------------------------
 
 class ArgumentContext final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ArgumentContext) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.ArgumentContext) */ {
  public:
   inline ArgumentContext() : ArgumentContext(nullptr) {}
   ~ArgumentContext() override;
@@ -2620,7 +2626,7 @@ class ArgumentContext final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "ArgumentContext";
+    return "rsh.protocol.ArgumentContext";
   }
   protected:
   explicit ArgumentContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -2669,20 +2675,20 @@ class ArgumentContext final :
   void _internal_set_object(bool value);
   public:
 
-  // optional .Type type = 4;
+  // optional .rsh.protocol.Type type = 4;
   bool has_type() const;
   private:
   bool _internal_has_type() const;
   public:
   void clear_type();
-  ::Type type() const;
-  void set_type(::Type value);
+  ::rsh::protocol::Type type() const;
+  void set_type(::rsh::protocol::Type value);
   private:
-  ::Type _internal_type() const;
-  void _internal_set_type(::Type value);
+  ::rsh::protocol::Type _internal_type() const;
+  void _internal_set_type(::rsh::protocol::Type value);
   public:
 
-  // @@protoc_insertion_point(class_scope:ArgumentContext)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.ArgumentContext)
  private:
   class _Internal;
 
@@ -2703,7 +2709,7 @@ class ArgumentContext final :
 // -------------------------------------------------------------------
 
 class Context final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Context) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Context) */ {
  public:
   inline Context() : Context(nullptr) {}
   ~Context() override;
@@ -2806,7 +2812,7 @@ class Context final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Context";
+    return "rsh.protocol.Context";
   }
   protected:
   explicit Context(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -2826,43 +2832,43 @@ class Context final :
     kArgumentContextFieldNumber = 2,
     kCallContextFieldNumber = 1,
   };
-  // repeated .ArgumentContext argument_context = 2;
+  // repeated .rsh.protocol.ArgumentContext argument_context = 2;
   int argument_context_size() const;
   private:
   int _internal_argument_context_size() const;
   public:
   void clear_argument_context();
-  ::ArgumentContext* mutable_argument_context(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >*
+  ::rsh::protocol::ArgumentContext* mutable_argument_context(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::ArgumentContext >*
       mutable_argument_context();
   private:
-  const ::ArgumentContext& _internal_argument_context(int index) const;
-  ::ArgumentContext* _internal_add_argument_context();
+  const ::rsh::protocol::ArgumentContext& _internal_argument_context(int index) const;
+  ::rsh::protocol::ArgumentContext* _internal_add_argument_context();
   public:
-  const ::ArgumentContext& argument_context(int index) const;
-  ::ArgumentContext* add_argument_context();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >&
+  const ::rsh::protocol::ArgumentContext& argument_context(int index) const;
+  ::rsh::protocol::ArgumentContext* add_argument_context();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::ArgumentContext >&
       argument_context() const;
 
-  // .CallContext call_context = 1;
+  // .rsh.protocol.CallContext call_context = 1;
   bool has_call_context() const;
   private:
   bool _internal_has_call_context() const;
   public:
   void clear_call_context();
-  const ::CallContext& call_context() const;
-  PROTOBUF_NODISCARD ::CallContext* release_call_context();
-  ::CallContext* mutable_call_context();
-  void set_allocated_call_context(::CallContext* call_context);
+  const ::rsh::protocol::CallContext& call_context() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::CallContext* release_call_context();
+  ::rsh::protocol::CallContext* mutable_call_context();
+  void set_allocated_call_context(::rsh::protocol::CallContext* call_context);
   private:
-  const ::CallContext& _internal_call_context() const;
-  ::CallContext* _internal_mutable_call_context();
+  const ::rsh::protocol::CallContext& _internal_call_context() const;
+  ::rsh::protocol::CallContext* _internal_mutable_call_context();
   public:
   void unsafe_arena_set_allocated_call_context(
-      ::CallContext* call_context);
-  ::CallContext* unsafe_arena_release_call_context();
+      ::rsh::protocol::CallContext* call_context);
+  ::rsh::protocol::CallContext* unsafe_arena_release_call_context();
 
-  // @@protoc_insertion_point(class_scope:Context)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Context)
  private:
   class _Internal;
 
@@ -2870,8 +2876,8 @@ class Context final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext > argument_context_;
-    ::CallContext* call_context_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::ArgumentContext > argument_context_;
+    ::rsh::protocol::CallContext* call_context_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -2880,7 +2886,7 @@ class Context final :
 // -------------------------------------------------------------------
 
 class ContextRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ContextRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.ContextRequest) */ {
  public:
   inline ContextRequest() : ContextRequest(nullptr) {}
   ~ContextRequest() override;
@@ -2983,7 +2989,7 @@ class ContextRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "ContextRequest";
+    return "rsh.protocol.ContextRequest";
   }
   protected:
   explicit ContextRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -3002,25 +3008,25 @@ class ContextRequest final :
   enum : int {
     kFunctionFieldNumber = 1,
   };
-  // .Function function = 1;
+  // .rsh.protocol.Function function = 1;
   bool has_function() const;
   private:
   bool _internal_has_function() const;
   public:
   void clear_function();
-  const ::Function& function() const;
-  PROTOBUF_NODISCARD ::Function* release_function();
-  ::Function* mutable_function();
-  void set_allocated_function(::Function* function);
+  const ::rsh::protocol::Function& function() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Function* release_function();
+  ::rsh::protocol::Function* mutable_function();
+  void set_allocated_function(::rsh::protocol::Function* function);
   private:
-  const ::Function& _internal_function() const;
-  ::Function* _internal_mutable_function();
+  const ::rsh::protocol::Function& _internal_function() const;
+  ::rsh::protocol::Function* _internal_mutable_function();
   public:
   void unsafe_arena_set_allocated_function(
-      ::Function* function);
-  ::Function* unsafe_arena_release_function();
+      ::rsh::protocol::Function* function);
+  ::rsh::protocol::Function* unsafe_arena_release_function();
 
-  // @@protoc_insertion_point(class_scope:ContextRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.ContextRequest)
  private:
   class _Internal;
 
@@ -3028,7 +3034,7 @@ class ContextRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::Function* function_;
+    ::rsh::protocol::Function* function_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -3037,7 +3043,7 @@ class ContextRequest final :
 // -------------------------------------------------------------------
 
 class TestFeedback final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TestFeedback) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.TestFeedback) */ {
  public:
   inline TestFeedback() : TestFeedback(nullptr) {}
   ~TestFeedback() override;
@@ -3140,7 +3146,7 @@ class TestFeedback final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "TestFeedback";
+    return "rsh.protocol.TestFeedback";
   }
   protected:
   explicit TestFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -3159,16 +3165,16 @@ class TestFeedback final :
   enum : int {
     kTestLatticeFieldNumber = 1,
   };
-  // .TestLattice test_lattice = 1;
+  // .rsh.protocol.TestLattice test_lattice = 1;
   void clear_test_lattice();
-  ::TestLattice test_lattice() const;
-  void set_test_lattice(::TestLattice value);
+  ::rsh::protocol::TestLattice test_lattice() const;
+  void set_test_lattice(::rsh::protocol::TestLattice value);
   private:
-  ::TestLattice _internal_test_lattice() const;
-  void _internal_set_test_lattice(::TestLattice value);
+  ::rsh::protocol::TestLattice _internal_test_lattice() const;
+  void _internal_set_test_lattice(::rsh::protocol::TestLattice value);
   public:
 
-  // @@protoc_insertion_point(class_scope:TestFeedback)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.TestFeedback)
  private:
   class _Internal;
 
@@ -3185,7 +3191,7 @@ class TestFeedback final :
 // -------------------------------------------------------------------
 
 class CallFeedback final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CallFeedback) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.CallFeedback) */ {
  public:
   inline CallFeedback() : CallFeedback(nullptr) {}
   ~CallFeedback() override;
@@ -3288,7 +3294,7 @@ class CallFeedback final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "CallFeedback";
+    return "rsh.protocol.CallFeedback";
   }
   protected:
   explicit CallFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -3331,7 +3337,7 @@ class CallFeedback final :
   void _internal_set_n_calls(int64_t value);
   public:
 
-  // @@protoc_insertion_point(class_scope:CallFeedback)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.CallFeedback)
  private:
   class _Internal;
 
@@ -3349,7 +3355,7 @@ class CallFeedback final :
 // -------------------------------------------------------------------
 
 class ValueFeedback final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ValueFeedback) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.ValueFeedback) */ {
  public:
   inline ValueFeedback() : ValueFeedback(nullptr) {}
   ~ValueFeedback() override;
@@ -3452,7 +3458,7 @@ class ValueFeedback final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "ValueFeedback";
+    return "rsh.protocol.ValueFeedback";
   }
   protected:
   explicit ValueFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -3520,7 +3526,7 @@ class ValueFeedback final :
   void _internal_set_is_promise(bool value);
   public:
 
-  // @@protoc_insertion_point(class_scope:ValueFeedback)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.ValueFeedback)
  private:
   class _Internal;
 
@@ -3541,7 +3547,7 @@ class ValueFeedback final :
 // -------------------------------------------------------------------
 
 class TypeFeedback_Feedback final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TypeFeedback.Feedback) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.TypeFeedback.Feedback) */ {
  public:
   inline TypeFeedback_Feedback() : TypeFeedback_Feedback(nullptr) {}
   ~TypeFeedback_Feedback() override;
@@ -3651,7 +3657,7 @@ class TypeFeedback_Feedback final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "TypeFeedback.Feedback";
+    return "rsh.protocol.TypeFeedback.Feedback";
   }
   protected:
   explicit TypeFeedback_Feedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -3672,63 +3678,63 @@ class TypeFeedback_Feedback final :
     kCallFeedbackFieldNumber = 2,
     kValueFeedbackFieldNumber = 3,
   };
-  // .TestFeedback test_feedback = 1;
+  // .rsh.protocol.TestFeedback test_feedback = 1;
   bool has_test_feedback() const;
   private:
   bool _internal_has_test_feedback() const;
   public:
   void clear_test_feedback();
-  const ::TestFeedback& test_feedback() const;
-  PROTOBUF_NODISCARD ::TestFeedback* release_test_feedback();
-  ::TestFeedback* mutable_test_feedback();
-  void set_allocated_test_feedback(::TestFeedback* test_feedback);
+  const ::rsh::protocol::TestFeedback& test_feedback() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::TestFeedback* release_test_feedback();
+  ::rsh::protocol::TestFeedback* mutable_test_feedback();
+  void set_allocated_test_feedback(::rsh::protocol::TestFeedback* test_feedback);
   private:
-  const ::TestFeedback& _internal_test_feedback() const;
-  ::TestFeedback* _internal_mutable_test_feedback();
+  const ::rsh::protocol::TestFeedback& _internal_test_feedback() const;
+  ::rsh::protocol::TestFeedback* _internal_mutable_test_feedback();
   public:
   void unsafe_arena_set_allocated_test_feedback(
-      ::TestFeedback* test_feedback);
-  ::TestFeedback* unsafe_arena_release_test_feedback();
+      ::rsh::protocol::TestFeedback* test_feedback);
+  ::rsh::protocol::TestFeedback* unsafe_arena_release_test_feedback();
 
-  // .CallFeedback call_feedback = 2;
+  // .rsh.protocol.CallFeedback call_feedback = 2;
   bool has_call_feedback() const;
   private:
   bool _internal_has_call_feedback() const;
   public:
   void clear_call_feedback();
-  const ::CallFeedback& call_feedback() const;
-  PROTOBUF_NODISCARD ::CallFeedback* release_call_feedback();
-  ::CallFeedback* mutable_call_feedback();
-  void set_allocated_call_feedback(::CallFeedback* call_feedback);
+  const ::rsh::protocol::CallFeedback& call_feedback() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::CallFeedback* release_call_feedback();
+  ::rsh::protocol::CallFeedback* mutable_call_feedback();
+  void set_allocated_call_feedback(::rsh::protocol::CallFeedback* call_feedback);
   private:
-  const ::CallFeedback& _internal_call_feedback() const;
-  ::CallFeedback* _internal_mutable_call_feedback();
+  const ::rsh::protocol::CallFeedback& _internal_call_feedback() const;
+  ::rsh::protocol::CallFeedback* _internal_mutable_call_feedback();
   public:
   void unsafe_arena_set_allocated_call_feedback(
-      ::CallFeedback* call_feedback);
-  ::CallFeedback* unsafe_arena_release_call_feedback();
+      ::rsh::protocol::CallFeedback* call_feedback);
+  ::rsh::protocol::CallFeedback* unsafe_arena_release_call_feedback();
 
-  // .ValueFeedback value_feedback = 3;
+  // .rsh.protocol.ValueFeedback value_feedback = 3;
   bool has_value_feedback() const;
   private:
   bool _internal_has_value_feedback() const;
   public:
   void clear_value_feedback();
-  const ::ValueFeedback& value_feedback() const;
-  PROTOBUF_NODISCARD ::ValueFeedback* release_value_feedback();
-  ::ValueFeedback* mutable_value_feedback();
-  void set_allocated_value_feedback(::ValueFeedback* value_feedback);
+  const ::rsh::protocol::ValueFeedback& value_feedback() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::ValueFeedback* release_value_feedback();
+  ::rsh::protocol::ValueFeedback* mutable_value_feedback();
+  void set_allocated_value_feedback(::rsh::protocol::ValueFeedback* value_feedback);
   private:
-  const ::ValueFeedback& _internal_value_feedback() const;
-  ::ValueFeedback* _internal_mutable_value_feedback();
+  const ::rsh::protocol::ValueFeedback& _internal_value_feedback() const;
+  ::rsh::protocol::ValueFeedback* _internal_mutable_value_feedback();
   public:
   void unsafe_arena_set_allocated_value_feedback(
-      ::ValueFeedback* value_feedback);
-  ::ValueFeedback* unsafe_arena_release_value_feedback();
+      ::rsh::protocol::ValueFeedback* value_feedback);
+  ::rsh::protocol::ValueFeedback* unsafe_arena_release_value_feedback();
 
   void clear_feedback();
   FeedbackCase feedback_case() const;
-  // @@protoc_insertion_point(class_scope:TypeFeedback.Feedback)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.TypeFeedback.Feedback)
  private:
   class _Internal;
   void set_has_test_feedback();
@@ -3745,9 +3751,9 @@ class TypeFeedback_Feedback final :
     union FeedbackUnion {
       constexpr FeedbackUnion() : _constinit_{} {}
         ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-      ::TestFeedback* test_feedback_;
-      ::CallFeedback* call_feedback_;
-      ::ValueFeedback* value_feedback_;
+      ::rsh::protocol::TestFeedback* test_feedback_;
+      ::rsh::protocol::CallFeedback* call_feedback_;
+      ::rsh::protocol::ValueFeedback* value_feedback_;
     } feedback_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
     uint32_t _oneof_case_[1];
@@ -3759,12 +3765,12 @@ class TypeFeedback_Feedback final :
 // -------------------------------------------------------------------
 
 class TypeFeedback_TypesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<TypeFeedback_TypesEntry_DoNotUse, 
-    int64_t, ::TypeFeedback_Feedback,
+    int64_t, ::rsh::protocol::TypeFeedback_Feedback,
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
 public:
   typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<TypeFeedback_TypesEntry_DoNotUse, 
-    int64_t, ::TypeFeedback_Feedback,
+    int64_t, ::rsh::protocol::TypeFeedback_Feedback,
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
   TypeFeedback_TypesEntry_DoNotUse();
@@ -3783,7 +3789,7 @@ class TypeFeedback_TypesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::interna
 // -------------------------------------------------------------------
 
 class TypeFeedback final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:TypeFeedback) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.TypeFeedback) */ {
  public:
   inline TypeFeedback() : TypeFeedback(nullptr) {}
   ~TypeFeedback() override;
@@ -3886,7 +3892,7 @@ class TypeFeedback final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "TypeFeedback";
+    return "rsh.protocol.TypeFeedback";
   }
   protected:
   explicit TypeFeedback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -3909,24 +3915,24 @@ class TypeFeedback final :
   enum : int {
     kTypesFieldNumber = 2,
   };
-  // map<int64, .TypeFeedback.Feedback> types = 2;
+  // map<int64, .rsh.protocol.TypeFeedback.Feedback> types = 2;
   int types_size() const;
   private:
   int _internal_types_size() const;
   public:
   void clear_types();
   private:
-  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >&
       _internal_types() const;
-  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >*
       _internal_mutable_types();
   public:
-  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >&
       types() const;
-  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >*
       mutable_types();
 
-  // @@protoc_insertion_point(class_scope:TypeFeedback)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.TypeFeedback)
  private:
   class _Internal;
 
@@ -3936,7 +3942,7 @@ class TypeFeedback final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::internal::MapField<
         TypeFeedback_TypesEntry_DoNotUse,
-        int64_t, ::TypeFeedback_Feedback,
+        int64_t, ::rsh::protocol::TypeFeedback_Feedback,
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> types_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
@@ -3947,7 +3953,7 @@ class TypeFeedback final :
 // -------------------------------------------------------------------
 
 class FeedbackRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:FeedbackRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.FeedbackRequest) */ {
  public:
   inline FeedbackRequest() : FeedbackRequest(nullptr) {}
   ~FeedbackRequest() override;
@@ -4050,7 +4056,7 @@ class FeedbackRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "FeedbackRequest";
+    return "rsh.protocol.FeedbackRequest";
   }
   protected:
   explicit FeedbackRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -4069,25 +4075,25 @@ class FeedbackRequest final :
   enum : int {
     kFunctionFieldNumber = 1,
   };
-  // .Function function = 1;
+  // .rsh.protocol.Function function = 1;
   bool has_function() const;
   private:
   bool _internal_has_function() const;
   public:
   void clear_function();
-  const ::Function& function() const;
-  PROTOBUF_NODISCARD ::Function* release_function();
-  ::Function* mutable_function();
-  void set_allocated_function(::Function* function);
+  const ::rsh::protocol::Function& function() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Function* release_function();
+  ::rsh::protocol::Function* mutable_function();
+  void set_allocated_function(::rsh::protocol::Function* function);
   private:
-  const ::Function& _internal_function() const;
-  ::Function* _internal_mutable_function();
+  const ::rsh::protocol::Function& _internal_function() const;
+  ::rsh::protocol::Function* _internal_mutable_function();
   public:
   void unsafe_arena_set_allocated_function(
-      ::Function* function);
-  ::Function* unsafe_arena_release_function();
+      ::rsh::protocol::Function* function);
+  ::rsh::protocol::Function* unsafe_arena_release_function();
 
-  // @@protoc_insertion_point(class_scope:FeedbackRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.FeedbackRequest)
  private:
   class _Internal;
 
@@ -4095,7 +4101,7 @@ class FeedbackRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::Function* function_;
+    ::rsh::protocol::Function* function_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -4104,7 +4110,7 @@ class FeedbackRequest final :
 // -------------------------------------------------------------------
 
 class PackageSource final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PackageSource) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.PackageSource) */ {
  public:
   inline PackageSource() : PackageSource(nullptr) {}
   ~PackageSource() override;
@@ -4213,7 +4219,7 @@ class PackageSource final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "PackageSource";
+    return "rsh.protocol.PackageSource";
   }
   protected:
   explicit PackageSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -4271,7 +4277,7 @@ class PackageSource final :
 
   void clear_source();
   SourceCase source_case() const;
-  // @@protoc_insertion_point(class_scope:PackageSource)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.PackageSource)
  private:
   class _Internal;
   void set_has_r_mirror();
@@ -4300,7 +4306,7 @@ class PackageSource final :
 // -------------------------------------------------------------------
 
 class Package final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Package) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.Package) */ {
  public:
   inline Package() : Package(nullptr) {}
   ~Package() override;
@@ -4403,7 +4409,7 @@ class Package final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "Package";
+    return "rsh.protocol.Package";
   }
   protected:
   explicit Package(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -4463,43 +4469,43 @@ class Package final :
   std::string* _internal_mutable_name();
   public:
 
-  // .Version version = 2;
+  // .rsh.protocol.Version version = 2;
   bool has_version() const;
   private:
   bool _internal_has_version() const;
   public:
   void clear_version();
-  const ::Version& version() const;
-  PROTOBUF_NODISCARD ::Version* release_version();
-  ::Version* mutable_version();
-  void set_allocated_version(::Version* version);
+  const ::rsh::protocol::Version& version() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::Version* release_version();
+  ::rsh::protocol::Version* mutable_version();
+  void set_allocated_version(::rsh::protocol::Version* version);
   private:
-  const ::Version& _internal_version() const;
-  ::Version* _internal_mutable_version();
+  const ::rsh::protocol::Version& _internal_version() const;
+  ::rsh::protocol::Version* _internal_mutable_version();
   public:
   void unsafe_arena_set_allocated_version(
-      ::Version* version);
-  ::Version* unsafe_arena_release_version();
+      ::rsh::protocol::Version* version);
+  ::rsh::protocol::Version* unsafe_arena_release_version();
 
-  // optional .PackageSource source = 5;
+  // optional .rsh.protocol.PackageSource source = 5;
   bool has_source() const;
   private:
   bool _internal_has_source() const;
   public:
   void clear_source();
-  const ::PackageSource& source() const;
-  PROTOBUF_NODISCARD ::PackageSource* release_source();
-  ::PackageSource* mutable_source();
-  void set_allocated_source(::PackageSource* source);
+  const ::rsh::protocol::PackageSource& source() const;
+  PROTOBUF_NODISCARD ::rsh::protocol::PackageSource* release_source();
+  ::rsh::protocol::PackageSource* mutable_source();
+  void set_allocated_source(::rsh::protocol::PackageSource* source);
   private:
-  const ::PackageSource& _internal_source() const;
-  ::PackageSource* _internal_mutable_source();
+  const ::rsh::protocol::PackageSource& _internal_source() const;
+  ::rsh::protocol::PackageSource* _internal_mutable_source();
   public:
   void unsafe_arena_set_allocated_source(
-      ::PackageSource* source);
-  ::PackageSource* unsafe_arena_release_source();
+      ::rsh::protocol::PackageSource* source);
+  ::rsh::protocol::PackageSource* unsafe_arena_release_source();
 
-  // @@protoc_insertion_point(class_scope:Package)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.Package)
  private:
   class _Internal;
 
@@ -4511,8 +4517,8 @@ class Package final :
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> function_hashes_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::Version* version_;
-    ::PackageSource* source_;
+    ::rsh::protocol::Version* version_;
+    ::rsh::protocol::PackageSource* source_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2eproto;
@@ -4520,7 +4526,7 @@ class Package final :
 // -------------------------------------------------------------------
 
 class PackageRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:PackageRequest) */ {
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.protocol.PackageRequest) */ {
  public:
   inline PackageRequest() : PackageRequest(nullptr) {}
   ~PackageRequest() override;
@@ -4623,7 +4629,7 @@ class PackageRequest final :
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "PackageRequest";
+    return "rsh.protocol.PackageRequest";
   }
   protected:
   explicit PackageRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -4656,7 +4662,7 @@ class PackageRequest final :
   std::string* _internal_mutable_hash();
   public:
 
-  // @@protoc_insertion_point(class_scope:PackageRequest)
+  // @@protoc_insertion_point(class_scope:rsh.protocol.PackageRequest)
  private:
   class _Internal;
 
@@ -4689,7 +4695,7 @@ inline int32_t Version::_internal_major() const {
   return _impl_.major_;
 }
 inline int32_t Version::major() const {
-  // @@protoc_insertion_point(field_get:Version.major)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Version.major)
   return _internal_major();
 }
 inline void Version::_internal_set_major(int32_t value) {
@@ -4698,7 +4704,7 @@ inline void Version::_internal_set_major(int32_t value) {
 }
 inline void Version::set_major(int32_t value) {
   _internal_set_major(value);
-  // @@protoc_insertion_point(field_set:Version.major)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Version.major)
 }
 
 // int32 minor = 2;
@@ -4709,7 +4715,7 @@ inline int32_t Version::_internal_minor() const {
   return _impl_.minor_;
 }
 inline int32_t Version::minor() const {
-  // @@protoc_insertion_point(field_get:Version.minor)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Version.minor)
   return _internal_minor();
 }
 inline void Version::_internal_set_minor(int32_t value) {
@@ -4718,7 +4724,7 @@ inline void Version::_internal_set_minor(int32_t value) {
 }
 inline void Version::set_minor(int32_t value) {
   _internal_set_minor(value);
-  // @@protoc_insertion_point(field_set:Version.minor)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Version.minor)
 }
 
 // int32 patch = 3;
@@ -4729,7 +4735,7 @@ inline int32_t Version::_internal_patch() const {
   return _impl_.patch_;
 }
 inline int32_t Version::patch() const {
-  // @@protoc_insertion_point(field_get:Version.patch)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Version.patch)
   return _internal_patch();
 }
 inline void Version::_internal_set_patch(int32_t value) {
@@ -4738,14 +4744,14 @@ inline void Version::_internal_set_patch(int32_t value) {
 }
 inline void Version::set_patch(int32_t value) {
   _internal_set_patch(value);
-  // @@protoc_insertion_point(field_set:Version.patch)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Version.patch)
 }
 
 // -------------------------------------------------------------------
 
 // InitRequest
 
-// .Version Rsh_version = 1;
+// .rsh.protocol.Version Rsh_version = 1;
 inline bool InitRequest::_internal_has_rsh_version() const {
   return this != internal_default_instance() && _impl_.rsh_version_ != nullptr;
 }
@@ -4758,17 +4764,17 @@ inline void InitRequest::clear_rsh_version() {
   }
   _impl_.rsh_version_ = nullptr;
 }
-inline const ::Version& InitRequest::_internal_rsh_version() const {
-  const ::Version* p = _impl_.rsh_version_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Version&>(
-      ::_Version_default_instance_);
+inline const ::rsh::protocol::Version& InitRequest::_internal_rsh_version() const {
+  const ::rsh::protocol::Version* p = _impl_.rsh_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Version&>(
+      ::rsh::protocol::_Version_default_instance_);
 }
-inline const ::Version& InitRequest::rsh_version() const {
-  // @@protoc_insertion_point(field_get:InitRequest.Rsh_version)
+inline const ::rsh::protocol::Version& InitRequest::rsh_version() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.InitRequest.Rsh_version)
   return _internal_rsh_version();
 }
 inline void InitRequest::unsafe_arena_set_allocated_rsh_version(
-    ::Version* rsh_version) {
+    ::rsh::protocol::Version* rsh_version) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rsh_version_);
   }
@@ -4778,11 +4784,11 @@ inline void InitRequest::unsafe_arena_set_allocated_rsh_version(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:InitRequest.Rsh_version)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.InitRequest.Rsh_version)
 }
-inline ::Version* InitRequest::release_rsh_version() {
+inline ::rsh::protocol::Version* InitRequest::release_rsh_version() {
   
-  ::Version* temp = _impl_.rsh_version_;
+  ::rsh::protocol::Version* temp = _impl_.rsh_version_;
   _impl_.rsh_version_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -4795,27 +4801,27 @@ inline ::Version* InitRequest::release_rsh_version() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Version* InitRequest::unsafe_arena_release_rsh_version() {
-  // @@protoc_insertion_point(field_release:InitRequest.Rsh_version)
+inline ::rsh::protocol::Version* InitRequest::unsafe_arena_release_rsh_version() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.InitRequest.Rsh_version)
   
-  ::Version* temp = _impl_.rsh_version_;
+  ::rsh::protocol::Version* temp = _impl_.rsh_version_;
   _impl_.rsh_version_ = nullptr;
   return temp;
 }
-inline ::Version* InitRequest::_internal_mutable_rsh_version() {
+inline ::rsh::protocol::Version* InitRequest::_internal_mutable_rsh_version() {
   
   if (_impl_.rsh_version_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Version>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Version>(GetArenaForAllocation());
     _impl_.rsh_version_ = p;
   }
   return _impl_.rsh_version_;
 }
-inline ::Version* InitRequest::mutable_rsh_version() {
-  ::Version* _msg = _internal_mutable_rsh_version();
-  // @@protoc_insertion_point(field_mutable:InitRequest.Rsh_version)
+inline ::rsh::protocol::Version* InitRequest::mutable_rsh_version() {
+  ::rsh::protocol::Version* _msg = _internal_mutable_rsh_version();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.InitRequest.Rsh_version)
   return _msg;
 }
-inline void InitRequest::set_allocated_rsh_version(::Version* rsh_version) {
+inline void InitRequest::set_allocated_rsh_version(::rsh::protocol::Version* rsh_version) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.rsh_version_;
@@ -4832,10 +4838,10 @@ inline void InitRequest::set_allocated_rsh_version(::Version* rsh_version) {
     
   }
   _impl_.rsh_version_ = rsh_version;
-  // @@protoc_insertion_point(field_set_allocated:InitRequest.Rsh_version)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.InitRequest.Rsh_version)
 }
 
-// .Version R_version = 2;
+// .rsh.protocol.Version R_version = 2;
 inline bool InitRequest::_internal_has_r_version() const {
   return this != internal_default_instance() && _impl_.r_version_ != nullptr;
 }
@@ -4848,17 +4854,17 @@ inline void InitRequest::clear_r_version() {
   }
   _impl_.r_version_ = nullptr;
 }
-inline const ::Version& InitRequest::_internal_r_version() const {
-  const ::Version* p = _impl_.r_version_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Version&>(
-      ::_Version_default_instance_);
+inline const ::rsh::protocol::Version& InitRequest::_internal_r_version() const {
+  const ::rsh::protocol::Version* p = _impl_.r_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Version&>(
+      ::rsh::protocol::_Version_default_instance_);
 }
-inline const ::Version& InitRequest::r_version() const {
-  // @@protoc_insertion_point(field_get:InitRequest.R_version)
+inline const ::rsh::protocol::Version& InitRequest::r_version() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.InitRequest.R_version)
   return _internal_r_version();
 }
 inline void InitRequest::unsafe_arena_set_allocated_r_version(
-    ::Version* r_version) {
+    ::rsh::protocol::Version* r_version) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.r_version_);
   }
@@ -4868,11 +4874,11 @@ inline void InitRequest::unsafe_arena_set_allocated_r_version(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:InitRequest.R_version)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.InitRequest.R_version)
 }
-inline ::Version* InitRequest::release_r_version() {
+inline ::rsh::protocol::Version* InitRequest::release_r_version() {
   
-  ::Version* temp = _impl_.r_version_;
+  ::rsh::protocol::Version* temp = _impl_.r_version_;
   _impl_.r_version_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -4885,27 +4891,27 @@ inline ::Version* InitRequest::release_r_version() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Version* InitRequest::unsafe_arena_release_r_version() {
-  // @@protoc_insertion_point(field_release:InitRequest.R_version)
+inline ::rsh::protocol::Version* InitRequest::unsafe_arena_release_r_version() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.InitRequest.R_version)
   
-  ::Version* temp = _impl_.r_version_;
+  ::rsh::protocol::Version* temp = _impl_.r_version_;
   _impl_.r_version_ = nullptr;
   return temp;
 }
-inline ::Version* InitRequest::_internal_mutable_r_version() {
+inline ::rsh::protocol::Version* InitRequest::_internal_mutable_r_version() {
   
   if (_impl_.r_version_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Version>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Version>(GetArenaForAllocation());
     _impl_.r_version_ = p;
   }
   return _impl_.r_version_;
 }
-inline ::Version* InitRequest::mutable_r_version() {
-  ::Version* _msg = _internal_mutable_r_version();
-  // @@protoc_insertion_point(field_mutable:InitRequest.R_version)
+inline ::rsh::protocol::Version* InitRequest::mutable_r_version() {
+  ::rsh::protocol::Version* _msg = _internal_mutable_r_version();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.InitRequest.R_version)
   return _msg;
 }
-inline void InitRequest::set_allocated_r_version(::Version* r_version) {
+inline void InitRequest::set_allocated_r_version(::rsh::protocol::Version* r_version) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.r_version_;
@@ -4922,7 +4928,7 @@ inline void InitRequest::set_allocated_r_version(::Version* r_version) {
     
   }
   _impl_.r_version_ = r_version;
-  // @@protoc_insertion_point(field_set_allocated:InitRequest.R_version)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.InitRequest.R_version)
 }
 
 // string platform = 3;
@@ -4930,7 +4936,7 @@ inline void InitRequest::clear_platform() {
   _impl_.platform_.ClearToEmpty();
 }
 inline const std::string& InitRequest::platform() const {
-  // @@protoc_insertion_point(field_get:InitRequest.platform)
+  // @@protoc_insertion_point(field_get:rsh.protocol.InitRequest.platform)
   return _internal_platform();
 }
 template <typename ArgT0, typename... ArgT>
@@ -4938,11 +4944,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void InitRequest::set_platform(ArgT0&& arg0, ArgT... args) {
  
  _impl_.platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:InitRequest.platform)
+  // @@protoc_insertion_point(field_set:rsh.protocol.InitRequest.platform)
 }
 inline std::string* InitRequest::mutable_platform() {
   std::string* _s = _internal_mutable_platform();
-  // @@protoc_insertion_point(field_mutable:InitRequest.platform)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.InitRequest.platform)
   return _s;
 }
 inline const std::string& InitRequest::_internal_platform() const {
@@ -4957,7 +4963,7 @@ inline std::string* InitRequest::_internal_mutable_platform() {
   return _impl_.platform_.Mutable(GetArenaForAllocation());
 }
 inline std::string* InitRequest::release_platform() {
-  // @@protoc_insertion_point(field_release:InitRequest.platform)
+  // @@protoc_insertion_point(field_release:rsh.protocol.InitRequest.platform)
   return _impl_.platform_.Release();
 }
 inline void InitRequest::set_allocated_platform(std::string* platform) {
@@ -4972,7 +4978,7 @@ inline void InitRequest::set_allocated_platform(std::string* platform) {
     _impl_.platform_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:InitRequest.platform)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.InitRequest.platform)
 }
 
 // repeated bytes package_hash = 4;
@@ -4987,66 +4993,66 @@ inline void InitRequest::clear_package_hash() {
 }
 inline std::string* InitRequest::add_package_hash() {
   std::string* _s = _internal_add_package_hash();
-  // @@protoc_insertion_point(field_add_mutable:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_add_mutable:rsh.protocol.InitRequest.package_hash)
   return _s;
 }
 inline const std::string& InitRequest::_internal_package_hash(int index) const {
   return _impl_.package_hash_.Get(index);
 }
 inline const std::string& InitRequest::package_hash(int index) const {
-  // @@protoc_insertion_point(field_get:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.InitRequest.package_hash)
   return _internal_package_hash(index);
 }
 inline std::string* InitRequest::mutable_package_hash(int index) {
-  // @@protoc_insertion_point(field_mutable:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.InitRequest.package_hash)
   return _impl_.package_hash_.Mutable(index);
 }
 inline void InitRequest::set_package_hash(int index, const std::string& value) {
   _impl_.package_hash_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.InitRequest.package_hash)
 }
 inline void InitRequest::set_package_hash(int index, std::string&& value) {
   _impl_.package_hash_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.InitRequest.package_hash)
 }
 inline void InitRequest::set_package_hash(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   _impl_.package_hash_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_set_char:rsh.protocol.InitRequest.package_hash)
 }
 inline void InitRequest::set_package_hash(int index, const void* value, size_t size) {
   _impl_.package_hash_.Mutable(index)->assign(
     reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_set_pointer:rsh.protocol.InitRequest.package_hash)
 }
 inline std::string* InitRequest::_internal_add_package_hash() {
   return _impl_.package_hash_.Add();
 }
 inline void InitRequest::add_package_hash(const std::string& value) {
   _impl_.package_hash_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_add:rsh.protocol.InitRequest.package_hash)
 }
 inline void InitRequest::add_package_hash(std::string&& value) {
   _impl_.package_hash_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_add:rsh.protocol.InitRequest.package_hash)
 }
 inline void InitRequest::add_package_hash(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   _impl_.package_hash_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_add_char:rsh.protocol.InitRequest.package_hash)
 }
 inline void InitRequest::add_package_hash(const void* value, size_t size) {
   _impl_.package_hash_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_add_pointer:rsh.protocol.InitRequest.package_hash)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
 InitRequest::package_hash() const {
-  // @@protoc_insertion_point(field_list:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_list:rsh.protocol.InitRequest.package_hash)
   return _impl_.package_hash_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
 InitRequest::mutable_package_hash() {
-  // @@protoc_insertion_point(field_mutable_list:InitRequest.package_hash)
+  // @@protoc_insertion_point(field_mutable_list:rsh.protocol.InitRequest.package_hash)
   return &_impl_.package_hash_;
 }
 
@@ -5058,7 +5064,7 @@ InitRequest::mutable_package_hash() {
 
 // CompileRequest
 
-// .Function function = 2;
+// .rsh.protocol.Function function = 2;
 inline bool CompileRequest::_internal_has_function() const {
   return this != internal_default_instance() && _impl_.function_ != nullptr;
 }
@@ -5071,17 +5077,17 @@ inline void CompileRequest::clear_function() {
   }
   _impl_.function_ = nullptr;
 }
-inline const ::Function& CompileRequest::_internal_function() const {
-  const ::Function* p = _impl_.function_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Function&>(
-      ::_Function_default_instance_);
+inline const ::rsh::protocol::Function& CompileRequest::_internal_function() const {
+  const ::rsh::protocol::Function* p = _impl_.function_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Function&>(
+      ::rsh::protocol::_Function_default_instance_);
 }
-inline const ::Function& CompileRequest::function() const {
-  // @@protoc_insertion_point(field_get:CompileRequest.function)
+inline const ::rsh::protocol::Function& CompileRequest::function() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileRequest.function)
   return _internal_function();
 }
 inline void CompileRequest::unsafe_arena_set_allocated_function(
-    ::Function* function) {
+    ::rsh::protocol::Function* function) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_);
   }
@@ -5091,11 +5097,11 @@ inline void CompileRequest::unsafe_arena_set_allocated_function(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CompileRequest.function)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.CompileRequest.function)
 }
-inline ::Function* CompileRequest::release_function() {
+inline ::rsh::protocol::Function* CompileRequest::release_function() {
   
-  ::Function* temp = _impl_.function_;
+  ::rsh::protocol::Function* temp = _impl_.function_;
   _impl_.function_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -5108,27 +5114,27 @@ inline ::Function* CompileRequest::release_function() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Function* CompileRequest::unsafe_arena_release_function() {
-  // @@protoc_insertion_point(field_release:CompileRequest.function)
+inline ::rsh::protocol::Function* CompileRequest::unsafe_arena_release_function() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileRequest.function)
   
-  ::Function* temp = _impl_.function_;
+  ::rsh::protocol::Function* temp = _impl_.function_;
   _impl_.function_ = nullptr;
   return temp;
 }
-inline ::Function* CompileRequest::_internal_mutable_function() {
+inline ::rsh::protocol::Function* CompileRequest::_internal_mutable_function() {
   
   if (_impl_.function_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Function>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Function>(GetArenaForAllocation());
     _impl_.function_ = p;
   }
   return _impl_.function_;
 }
-inline ::Function* CompileRequest::mutable_function() {
-  ::Function* _msg = _internal_mutable_function();
-  // @@protoc_insertion_point(field_mutable:CompileRequest.function)
+inline ::rsh::protocol::Function* CompileRequest::mutable_function() {
+  ::rsh::protocol::Function* _msg = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileRequest.function)
   return _msg;
 }
-inline void CompileRequest::set_allocated_function(::Function* function) {
+inline void CompileRequest::set_allocated_function(::rsh::protocol::Function* function) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.function_;
@@ -5145,10 +5151,10 @@ inline void CompileRequest::set_allocated_function(::Function* function) {
     
   }
   _impl_.function_ = function;
-  // @@protoc_insertion_point(field_set_allocated:CompileRequest.function)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileRequest.function)
 }
 
-// optional .Tier tier = 4;
+// optional .rsh.protocol.Tier tier = 4;
 inline bool CompileRequest::_internal_has_tier() const {
   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
   return value;
@@ -5160,20 +5166,20 @@ inline void CompileRequest::clear_tier() {
   _impl_.tier_ = 0;
   _impl_._has_bits_[0] &= ~0x00000004u;
 }
-inline ::Tier CompileRequest::_internal_tier() const {
-  return static_cast< ::Tier >(_impl_.tier_);
+inline ::rsh::protocol::Tier CompileRequest::_internal_tier() const {
+  return static_cast< ::rsh::protocol::Tier >(_impl_.tier_);
 }
-inline ::Tier CompileRequest::tier() const {
-  // @@protoc_insertion_point(field_get:CompileRequest.tier)
+inline ::rsh::protocol::Tier CompileRequest::tier() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileRequest.tier)
   return _internal_tier();
 }
-inline void CompileRequest::_internal_set_tier(::Tier value) {
+inline void CompileRequest::_internal_set_tier(::rsh::protocol::Tier value) {
   _impl_._has_bits_[0] |= 0x00000004u;
   _impl_.tier_ = value;
 }
-inline void CompileRequest::set_tier(::Tier value) {
+inline void CompileRequest::set_tier(::rsh::protocol::Tier value) {
   _internal_set_tier(value);
-  // @@protoc_insertion_point(field_set:CompileRequest.tier)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileRequest.tier)
 }
 
 // optional int32 optimization_level = 5;
@@ -5192,7 +5198,7 @@ inline int32_t CompileRequest::_internal_optimization_level() const {
   return _impl_.optimization_level_;
 }
 inline int32_t CompileRequest::optimization_level() const {
-  // @@protoc_insertion_point(field_get:CompileRequest.optimization_level)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileRequest.optimization_level)
   return _internal_optimization_level();
 }
 inline void CompileRequest::_internal_set_optimization_level(int32_t value) {
@@ -5201,10 +5207,10 @@ inline void CompileRequest::_internal_set_optimization_level(int32_t value) {
 }
 inline void CompileRequest::set_optimization_level(int32_t value) {
   _internal_set_optimization_level(value);
-  // @@protoc_insertion_point(field_set:CompileRequest.optimization_level)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileRequest.optimization_level)
 }
 
-// optional .Context context = 6;
+// optional .rsh.protocol.Context context = 6;
 inline bool CompileRequest::_internal_has_context() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.context_ != nullptr);
@@ -5217,17 +5223,17 @@ inline void CompileRequest::clear_context() {
   if (_impl_.context_ != nullptr) _impl_.context_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline const ::Context& CompileRequest::_internal_context() const {
-  const ::Context* p = _impl_.context_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Context&>(
-      ::_Context_default_instance_);
+inline const ::rsh::protocol::Context& CompileRequest::_internal_context() const {
+  const ::rsh::protocol::Context* p = _impl_.context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Context&>(
+      ::rsh::protocol::_Context_default_instance_);
 }
-inline const ::Context& CompileRequest::context() const {
-  // @@protoc_insertion_point(field_get:CompileRequest.context)
+inline const ::rsh::protocol::Context& CompileRequest::context() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileRequest.context)
   return _internal_context();
 }
 inline void CompileRequest::unsafe_arena_set_allocated_context(
-    ::Context* context) {
+    ::rsh::protocol::Context* context) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.context_);
   }
@@ -5237,11 +5243,11 @@ inline void CompileRequest::unsafe_arena_set_allocated_context(
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CompileRequest.context)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.CompileRequest.context)
 }
-inline ::Context* CompileRequest::release_context() {
+inline ::rsh::protocol::Context* CompileRequest::release_context() {
   _impl_._has_bits_[0] &= ~0x00000001u;
-  ::Context* temp = _impl_.context_;
+  ::rsh::protocol::Context* temp = _impl_.context_;
   _impl_.context_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -5254,27 +5260,27 @@ inline ::Context* CompileRequest::release_context() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Context* CompileRequest::unsafe_arena_release_context() {
-  // @@protoc_insertion_point(field_release:CompileRequest.context)
+inline ::rsh::protocol::Context* CompileRequest::unsafe_arena_release_context() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileRequest.context)
   _impl_._has_bits_[0] &= ~0x00000001u;
-  ::Context* temp = _impl_.context_;
+  ::rsh::protocol::Context* temp = _impl_.context_;
   _impl_.context_ = nullptr;
   return temp;
 }
-inline ::Context* CompileRequest::_internal_mutable_context() {
+inline ::rsh::protocol::Context* CompileRequest::_internal_mutable_context() {
   _impl_._has_bits_[0] |= 0x00000001u;
   if (_impl_.context_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Context>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Context>(GetArenaForAllocation());
     _impl_.context_ = p;
   }
   return _impl_.context_;
 }
-inline ::Context* CompileRequest::mutable_context() {
-  ::Context* _msg = _internal_mutable_context();
-  // @@protoc_insertion_point(field_mutable:CompileRequest.context)
+inline ::rsh::protocol::Context* CompileRequest::mutable_context() {
+  ::rsh::protocol::Context* _msg = _internal_mutable_context();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileRequest.context)
   return _msg;
 }
-inline void CompileRequest::set_allocated_context(::Context* context) {
+inline void CompileRequest::set_allocated_context(::rsh::protocol::Context* context) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.context_;
@@ -5291,10 +5297,10 @@ inline void CompileRequest::set_allocated_context(::Context* context) {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.context_ = context;
-  // @@protoc_insertion_point(field_set_allocated:CompileRequest.context)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileRequest.context)
 }
 
-// optional .Environment environment = 7;
+// optional .rsh.protocol.Environment environment = 7;
 inline bool CompileRequest::_internal_has_environment() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.environment_ != nullptr);
@@ -5307,17 +5313,17 @@ inline void CompileRequest::clear_environment() {
   if (_impl_.environment_ != nullptr) _impl_.environment_->Clear();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const ::Environment& CompileRequest::_internal_environment() const {
-  const ::Environment* p = _impl_.environment_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Environment&>(
-      ::_Environment_default_instance_);
+inline const ::rsh::protocol::Environment& CompileRequest::_internal_environment() const {
+  const ::rsh::protocol::Environment* p = _impl_.environment_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Environment&>(
+      ::rsh::protocol::_Environment_default_instance_);
 }
-inline const ::Environment& CompileRequest::environment() const {
-  // @@protoc_insertion_point(field_get:CompileRequest.environment)
+inline const ::rsh::protocol::Environment& CompileRequest::environment() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileRequest.environment)
   return _internal_environment();
 }
 inline void CompileRequest::unsafe_arena_set_allocated_environment(
-    ::Environment* environment) {
+    ::rsh::protocol::Environment* environment) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.environment_);
   }
@@ -5327,11 +5333,11 @@ inline void CompileRequest::unsafe_arena_set_allocated_environment(
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CompileRequest.environment)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.CompileRequest.environment)
 }
-inline ::Environment* CompileRequest::release_environment() {
+inline ::rsh::protocol::Environment* CompileRequest::release_environment() {
   _impl_._has_bits_[0] &= ~0x00000002u;
-  ::Environment* temp = _impl_.environment_;
+  ::rsh::protocol::Environment* temp = _impl_.environment_;
   _impl_.environment_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -5344,27 +5350,27 @@ inline ::Environment* CompileRequest::release_environment() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Environment* CompileRequest::unsafe_arena_release_environment() {
-  // @@protoc_insertion_point(field_release:CompileRequest.environment)
+inline ::rsh::protocol::Environment* CompileRequest::unsafe_arena_release_environment() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileRequest.environment)
   _impl_._has_bits_[0] &= ~0x00000002u;
-  ::Environment* temp = _impl_.environment_;
+  ::rsh::protocol::Environment* temp = _impl_.environment_;
   _impl_.environment_ = nullptr;
   return temp;
 }
-inline ::Environment* CompileRequest::_internal_mutable_environment() {
+inline ::rsh::protocol::Environment* CompileRequest::_internal_mutable_environment() {
   _impl_._has_bits_[0] |= 0x00000002u;
   if (_impl_.environment_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Environment>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Environment>(GetArenaForAllocation());
     _impl_.environment_ = p;
   }
   return _impl_.environment_;
 }
-inline ::Environment* CompileRequest::mutable_environment() {
-  ::Environment* _msg = _internal_mutable_environment();
-  // @@protoc_insertion_point(field_mutable:CompileRequest.environment)
+inline ::rsh::protocol::Environment* CompileRequest::mutable_environment() {
+  ::rsh::protocol::Environment* _msg = _internal_mutable_environment();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileRequest.environment)
   return _msg;
 }
-inline void CompileRequest::set_allocated_environment(::Environment* environment) {
+inline void CompileRequest::set_allocated_environment(::rsh::protocol::Environment* environment) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.environment_;
@@ -5381,7 +5387,7 @@ inline void CompileRequest::set_allocated_environment(::Environment* environment
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
   _impl_.environment_ = environment;
-  // @@protoc_insertion_point(field_set_allocated:CompileRequest.environment)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileRequest.environment)
 }
 
 // -------------------------------------------------------------------
@@ -5393,7 +5399,7 @@ inline void CompileResponse::clear_hash() {
   _impl_.hash_.ClearToEmpty();
 }
 inline const std::string& CompileResponse::hash() const {
-  // @@protoc_insertion_point(field_get:CompileResponse.hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.hash)
   return _internal_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5401,11 +5407,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void CompileResponse::set_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:CompileResponse.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.hash)
 }
 inline std::string* CompileResponse::mutable_hash() {
   std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:CompileResponse.hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileResponse.hash)
   return _s;
 }
 inline const std::string& CompileResponse::_internal_hash() const {
@@ -5420,7 +5426,7 @@ inline std::string* CompileResponse::_internal_mutable_hash() {
   return _impl_.hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompileResponse::release_hash() {
-  // @@protoc_insertion_point(field_release:CompileResponse.hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileResponse.hash)
   return _impl_.hash_.Release();
 }
 inline void CompileResponse::set_allocated_hash(std::string* hash) {
@@ -5435,27 +5441,27 @@ inline void CompileResponse::set_allocated_hash(std::string* hash) {
     _impl_.hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:CompileResponse.hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.hash)
 }
 
-// .Tier tier = 2;
+// .rsh.protocol.Tier tier = 2;
 inline void CompileResponse::clear_tier() {
   _impl_.tier_ = 0;
 }
-inline ::Tier CompileResponse::_internal_tier() const {
-  return static_cast< ::Tier >(_impl_.tier_);
+inline ::rsh::protocol::Tier CompileResponse::_internal_tier() const {
+  return static_cast< ::rsh::protocol::Tier >(_impl_.tier_);
 }
-inline ::Tier CompileResponse::tier() const {
-  // @@protoc_insertion_point(field_get:CompileResponse.tier)
+inline ::rsh::protocol::Tier CompileResponse::tier() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.tier)
   return _internal_tier();
 }
-inline void CompileResponse::_internal_set_tier(::Tier value) {
+inline void CompileResponse::_internal_set_tier(::rsh::protocol::Tier value) {
   
   _impl_.tier_ = value;
 }
-inline void CompileResponse::set_tier(::Tier value) {
+inline void CompileResponse::set_tier(::rsh::protocol::Tier value) {
   _internal_set_tier(value);
-  // @@protoc_insertion_point(field_set:CompileResponse.tier)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.tier)
 }
 
 // optional bytes code = 3;
@@ -5471,7 +5477,7 @@ inline void CompileResponse::clear_code() {
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& CompileResponse::code() const {
-  // @@protoc_insertion_point(field_get:CompileResponse.code)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.code)
   return _internal_code();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5479,11 +5485,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void CompileResponse::set_code(ArgT0&& arg0, ArgT... args) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.code_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:CompileResponse.code)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.code)
 }
 inline std::string* CompileResponse::mutable_code() {
   std::string* _s = _internal_mutable_code();
-  // @@protoc_insertion_point(field_mutable:CompileResponse.code)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileResponse.code)
   return _s;
 }
 inline const std::string& CompileResponse::_internal_code() const {
@@ -5498,7 +5504,7 @@ inline std::string* CompileResponse::_internal_mutable_code() {
   return _impl_.code_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompileResponse::release_code() {
-  // @@protoc_insertion_point(field_release:CompileResponse.code)
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileResponse.code)
   if (!_internal_has_code()) {
     return nullptr;
   }
@@ -5523,7 +5529,7 @@ inline void CompileResponse::set_allocated_code(std::string* code) {
     _impl_.code_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:CompileResponse.code)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.code)
 }
 
 // optional bytes constant_pool = 4;
@@ -5539,7 +5545,7 @@ inline void CompileResponse::clear_constant_pool() {
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
 inline const std::string& CompileResponse::constant_pool() const {
-  // @@protoc_insertion_point(field_get:CompileResponse.constant_pool)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.constant_pool)
   return _internal_constant_pool();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5547,11 +5553,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void CompileResponse::set_constant_pool(ArgT0&& arg0, ArgT... args) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.constant_pool_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:CompileResponse.constant_pool)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.constant_pool)
 }
 inline std::string* CompileResponse::mutable_constant_pool() {
   std::string* _s = _internal_mutable_constant_pool();
-  // @@protoc_insertion_point(field_mutable:CompileResponse.constant_pool)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileResponse.constant_pool)
   return _s;
 }
 inline const std::string& CompileResponse::_internal_constant_pool() const {
@@ -5566,7 +5572,7 @@ inline std::string* CompileResponse::_internal_mutable_constant_pool() {
   return _impl_.constant_pool_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CompileResponse::release_constant_pool() {
-  // @@protoc_insertion_point(field_release:CompileResponse.constant_pool)
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileResponse.constant_pool)
   if (!_internal_has_constant_pool()) {
     return nullptr;
   }
@@ -5591,7 +5597,7 @@ inline void CompileResponse::set_allocated_constant_pool(std::string* constant_p
     _impl_.constant_pool_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:CompileResponse.constant_pool)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.constant_pool)
 }
 
 // -------------------------------------------------------------------
@@ -5603,7 +5609,7 @@ inline void Function::clear_package_hash() {
   _impl_.package_hash_.ClearToEmpty();
 }
 inline const std::string& Function::package_hash() const {
-  // @@protoc_insertion_point(field_get:Function.package_hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Function.package_hash)
   return _internal_package_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5611,11 +5617,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Function::set_package_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.package_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Function.package_hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Function.package_hash)
 }
 inline std::string* Function::mutable_package_hash() {
   std::string* _s = _internal_mutable_package_hash();
-  // @@protoc_insertion_point(field_mutable:Function.package_hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Function.package_hash)
   return _s;
 }
 inline const std::string& Function::_internal_package_hash() const {
@@ -5630,7 +5636,7 @@ inline std::string* Function::_internal_mutable_package_hash() {
   return _impl_.package_hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Function::release_package_hash() {
-  // @@protoc_insertion_point(field_release:Function.package_hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Function.package_hash)
   return _impl_.package_hash_.Release();
 }
 inline void Function::set_allocated_package_hash(std::string* package_hash) {
@@ -5645,7 +5651,7 @@ inline void Function::set_allocated_package_hash(std::string* package_hash) {
     _impl_.package_hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Function.package_hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.package_hash)
 }
 
 // string name = 2;
@@ -5653,7 +5659,7 @@ inline void Function::clear_name() {
   _impl_.name_.ClearToEmpty();
 }
 inline const std::string& Function::name() const {
-  // @@protoc_insertion_point(field_get:Function.name)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Function.name)
   return _internal_name();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5661,11 +5667,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Function::set_name(ArgT0&& arg0, ArgT... args) {
  
  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Function.name)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Function.name)
 }
 inline std::string* Function::mutable_name() {
   std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:Function.name)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Function.name)
   return _s;
 }
 inline const std::string& Function::_internal_name() const {
@@ -5680,7 +5686,7 @@ inline std::string* Function::_internal_mutable_name() {
   return _impl_.name_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Function::release_name() {
-  // @@protoc_insertion_point(field_release:Function.name)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Function.name)
   return _impl_.name_.Release();
 }
 inline void Function::set_allocated_name(std::string* name) {
@@ -5695,7 +5701,7 @@ inline void Function::set_allocated_name(std::string* name) {
     _impl_.name_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Function.name)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.name)
 }
 
 // bytes hash = 3;
@@ -5703,7 +5709,7 @@ inline void Function::clear_hash() {
   _impl_.hash_.ClearToEmpty();
 }
 inline const std::string& Function::hash() const {
-  // @@protoc_insertion_point(field_get:Function.hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Function.hash)
   return _internal_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5711,11 +5717,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Function::set_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Function.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Function.hash)
 }
 inline std::string* Function::mutable_hash() {
   std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:Function.hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Function.hash)
   return _s;
 }
 inline const std::string& Function::_internal_hash() const {
@@ -5730,7 +5736,7 @@ inline std::string* Function::_internal_mutable_hash() {
   return _impl_.hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Function::release_hash() {
-  // @@protoc_insertion_point(field_release:Function.hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Function.hash)
   return _impl_.hash_.Release();
 }
 inline void Function::set_allocated_hash(std::string* hash) {
@@ -5745,7 +5751,7 @@ inline void Function::set_allocated_hash(std::string* hash) {
     _impl_.hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Function.hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.hash)
 }
 
 // optional bytes body = 4;
@@ -5761,7 +5767,7 @@ inline void Function::clear_body() {
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
 inline const std::string& Function::body() const {
-  // @@protoc_insertion_point(field_get:Function.body)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Function.body)
   return _internal_body();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5769,11 +5775,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Function::set_body(ArgT0&& arg0, ArgT... args) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.body_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Function.body)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Function.body)
 }
 inline std::string* Function::mutable_body() {
   std::string* _s = _internal_mutable_body();
-  // @@protoc_insertion_point(field_mutable:Function.body)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Function.body)
   return _s;
 }
 inline const std::string& Function::_internal_body() const {
@@ -5788,7 +5794,7 @@ inline std::string* Function::_internal_mutable_body() {
   return _impl_.body_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Function::release_body() {
-  // @@protoc_insertion_point(field_release:Function.body)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Function.body)
   if (!_internal_has_body()) {
     return nullptr;
   }
@@ -5813,7 +5819,7 @@ inline void Function::set_allocated_body(std::string* body) {
     _impl_.body_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Function.body)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.body)
 }
 
 // -------------------------------------------------------------------
@@ -5825,7 +5831,7 @@ inline void FunctionRequest::clear_hash() {
   _impl_.hash_.ClearToEmpty();
 }
 inline const std::string& FunctionRequest::hash() const {
-  // @@protoc_insertion_point(field_get:FunctionRequest.hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.FunctionRequest.hash)
   return _internal_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -5833,11 +5839,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void FunctionRequest::set_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:FunctionRequest.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.FunctionRequest.hash)
 }
 inline std::string* FunctionRequest::mutable_hash() {
   std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:FunctionRequest.hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.FunctionRequest.hash)
   return _s;
 }
 inline const std::string& FunctionRequest::_internal_hash() const {
@@ -5852,7 +5858,7 @@ inline std::string* FunctionRequest::_internal_mutable_hash() {
   return _impl_.hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* FunctionRequest::release_hash() {
-  // @@protoc_insertion_point(field_release:FunctionRequest.hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.FunctionRequest.hash)
   return _impl_.hash_.Release();
 }
 inline void FunctionRequest::set_allocated_hash(std::string* hash) {
@@ -5867,7 +5873,7 @@ inline void FunctionRequest::set_allocated_hash(std::string* hash) {
     _impl_.hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:FunctionRequest.hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.FunctionRequest.hash)
 }
 
 // -------------------------------------------------------------------
@@ -5892,7 +5898,7 @@ Environment::_internal_values() const {
 }
 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
 Environment::values() const {
-  // @@protoc_insertion_point(field_map:Environment.values)
+  // @@protoc_insertion_point(field_map:rsh.protocol.Environment.values)
   return _internal_values();
 }
 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
@@ -5901,7 +5907,7 @@ Environment::_internal_mutable_values() {
 }
 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
 Environment::mutable_values() {
-  // @@protoc_insertion_point(field_mutable_map:Environment.values)
+  // @@protoc_insertion_point(field_mutable_map:rsh.protocol.Environment.values)
   return _internal_mutable_values();
 }
 
@@ -5921,66 +5927,66 @@ inline void ValueRequest::clear_hash() {
 }
 inline std::string* ValueRequest::add_hash() {
   std::string* _s = _internal_add_hash();
-  // @@protoc_insertion_point(field_add_mutable:ValueRequest.hash)
+  // @@protoc_insertion_point(field_add_mutable:rsh.protocol.ValueRequest.hash)
   return _s;
 }
 inline const std::string& ValueRequest::_internal_hash(int index) const {
   return _impl_.hash_.Get(index);
 }
 inline const std::string& ValueRequest::hash(int index) const {
-  // @@protoc_insertion_point(field_get:ValueRequest.hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ValueRequest.hash)
   return _internal_hash(index);
 }
 inline std::string* ValueRequest::mutable_hash(int index) {
-  // @@protoc_insertion_point(field_mutable:ValueRequest.hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.ValueRequest.hash)
   return _impl_.hash_.Mutable(index);
 }
 inline void ValueRequest::set_hash(int index, const std::string& value) {
   _impl_.hash_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:ValueRequest.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueRequest.hash)
 }
 inline void ValueRequest::set_hash(int index, std::string&& value) {
   _impl_.hash_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:ValueRequest.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueRequest.hash)
 }
 inline void ValueRequest::set_hash(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   _impl_.hash_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:ValueRequest.hash)
+  // @@protoc_insertion_point(field_set_char:rsh.protocol.ValueRequest.hash)
 }
 inline void ValueRequest::set_hash(int index, const void* value, size_t size) {
   _impl_.hash_.Mutable(index)->assign(
     reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:ValueRequest.hash)
+  // @@protoc_insertion_point(field_set_pointer:rsh.protocol.ValueRequest.hash)
 }
 inline std::string* ValueRequest::_internal_add_hash() {
   return _impl_.hash_.Add();
 }
 inline void ValueRequest::add_hash(const std::string& value) {
   _impl_.hash_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:ValueRequest.hash)
+  // @@protoc_insertion_point(field_add:rsh.protocol.ValueRequest.hash)
 }
 inline void ValueRequest::add_hash(std::string&& value) {
   _impl_.hash_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:ValueRequest.hash)
+  // @@protoc_insertion_point(field_add:rsh.protocol.ValueRequest.hash)
 }
 inline void ValueRequest::add_hash(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   _impl_.hash_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:ValueRequest.hash)
+  // @@protoc_insertion_point(field_add_char:rsh.protocol.ValueRequest.hash)
 }
 inline void ValueRequest::add_hash(const void* value, size_t size) {
   _impl_.hash_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:ValueRequest.hash)
+  // @@protoc_insertion_point(field_add_pointer:rsh.protocol.ValueRequest.hash)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
 ValueRequest::hash() const {
-  // @@protoc_insertion_point(field_list:ValueRequest.hash)
+  // @@protoc_insertion_point(field_list:rsh.protocol.ValueRequest.hash)
   return _impl_.hash_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
 ValueRequest::mutable_hash() {
-  // @@protoc_insertion_point(field_mutable_list:ValueRequest.hash)
+  // @@protoc_insertion_point(field_mutable_list:rsh.protocol.ValueRequest.hash)
   return &_impl_.hash_;
 }
 
@@ -5993,7 +5999,7 @@ inline void Value::clear_hash() {
   _impl_.hash_.ClearToEmpty();
 }
 inline const std::string& Value::hash() const {
-  // @@protoc_insertion_point(field_get:Value.hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Value.hash)
   return _internal_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -6001,11 +6007,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Value::set_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Value.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Value.hash)
 }
 inline std::string* Value::mutable_hash() {
   std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:Value.hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Value.hash)
   return _s;
 }
 inline const std::string& Value::_internal_hash() const {
@@ -6020,7 +6026,7 @@ inline std::string* Value::_internal_mutable_hash() {
   return _impl_.hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Value::release_hash() {
-  // @@protoc_insertion_point(field_release:Value.hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Value.hash)
   return _impl_.hash_.Release();
 }
 inline void Value::set_allocated_hash(std::string* hash) {
@@ -6035,7 +6041,7 @@ inline void Value::set_allocated_hash(std::string* hash) {
     _impl_.hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Value.hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Value.hash)
 }
 
 // bytes value = 2;
@@ -6043,7 +6049,7 @@ inline void Value::clear_value() {
   _impl_.value_.ClearToEmpty();
 }
 inline const std::string& Value::value() const {
-  // @@protoc_insertion_point(field_get:Value.value)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Value.value)
   return _internal_value();
 }
 template <typename ArgT0, typename... ArgT>
@@ -6051,11 +6057,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Value::set_value(ArgT0&& arg0, ArgT... args) {
  
  _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Value.value)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Value.value)
 }
 inline std::string* Value::mutable_value() {
   std::string* _s = _internal_mutable_value();
-  // @@protoc_insertion_point(field_mutable:Value.value)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Value.value)
   return _s;
 }
 inline const std::string& Value::_internal_value() const {
@@ -6070,7 +6076,7 @@ inline std::string* Value::_internal_mutable_value() {
   return _impl_.value_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Value::release_value() {
-  // @@protoc_insertion_point(field_release:Value.value)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Value.value)
   return _impl_.value_.Release();
 }
 inline void Value::set_allocated_value(std::string* value) {
@@ -6085,14 +6091,14 @@ inline void Value::set_allocated_value(std::string* value) {
     _impl_.value_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Value.value)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Value.value)
 }
 
 // -------------------------------------------------------------------
 
 // Values
 
-// repeated .Value values = 1;
+// repeated .rsh.protocol.Value values = 1;
 inline int Values::_internal_values_size() const {
   return _impl_.values_.size();
 }
@@ -6102,33 +6108,33 @@ inline int Values::values_size() const {
 inline void Values::clear_values() {
   _impl_.values_.Clear();
 }
-inline ::Value* Values::mutable_values(int index) {
-  // @@protoc_insertion_point(field_mutable:Values.values)
+inline ::rsh::protocol::Value* Values::mutable_values(int index) {
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Values.values)
   return _impl_.values_.Mutable(index);
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >*
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::Value >*
 Values::mutable_values() {
-  // @@protoc_insertion_point(field_mutable_list:Values.values)
+  // @@protoc_insertion_point(field_mutable_list:rsh.protocol.Values.values)
   return &_impl_.values_;
 }
-inline const ::Value& Values::_internal_values(int index) const {
+inline const ::rsh::protocol::Value& Values::_internal_values(int index) const {
   return _impl_.values_.Get(index);
 }
-inline const ::Value& Values::values(int index) const {
-  // @@protoc_insertion_point(field_get:Values.values)
+inline const ::rsh::protocol::Value& Values::values(int index) const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.Values.values)
   return _internal_values(index);
 }
-inline ::Value* Values::_internal_add_values() {
+inline ::rsh::protocol::Value* Values::_internal_add_values() {
   return _impl_.values_.Add();
 }
-inline ::Value* Values::add_values() {
-  ::Value* _add = _internal_add_values();
-  // @@protoc_insertion_point(field_add:Values.values)
+inline ::rsh::protocol::Value* Values::add_values() {
+  ::rsh::protocol::Value* _add = _internal_add_values();
+  // @@protoc_insertion_point(field_add:rsh.protocol.Values.values)
   return _add;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Value >&
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::Value >&
 Values::values() const {
-  // @@protoc_insertion_point(field_list:Values.values)
+  // @@protoc_insertion_point(field_list:rsh.protocol.Values.values)
   return _impl_.values_;
 }
 
@@ -6148,7 +6154,7 @@ inline bool CallContext::_internal_args_statically_matched() const {
   return _impl_.args_statically_matched_;
 }
 inline bool CallContext::args_statically_matched() const {
-  // @@protoc_insertion_point(field_get:CallContext.args_statically_matched)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CallContext.args_statically_matched)
   return _internal_args_statically_matched();
 }
 inline void CallContext::_internal_set_args_statically_matched(bool value) {
@@ -6157,7 +6163,7 @@ inline void CallContext::_internal_set_args_statically_matched(bool value) {
 }
 inline void CallContext::set_args_statically_matched(bool value) {
   _internal_set_args_statically_matched(value);
-  // @@protoc_insertion_point(field_set:CallContext.args_statically_matched)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallContext.args_statically_matched)
 }
 
 // bool correct_number_of_args = 2;
@@ -6168,7 +6174,7 @@ inline bool CallContext::_internal_correct_number_of_args() const {
   return _impl_.correct_number_of_args_;
 }
 inline bool CallContext::correct_number_of_args() const {
-  // @@protoc_insertion_point(field_get:CallContext.correct_number_of_args)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CallContext.correct_number_of_args)
   return _internal_correct_number_of_args();
 }
 inline void CallContext::_internal_set_correct_number_of_args(bool value) {
@@ -6177,7 +6183,7 @@ inline void CallContext::_internal_set_correct_number_of_args(bool value) {
 }
 inline void CallContext::set_correct_number_of_args(bool value) {
   _internal_set_correct_number_of_args(value);
-  // @@protoc_insertion_point(field_set:CallContext.correct_number_of_args)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallContext.correct_number_of_args)
 }
 
 // bool correct_order_of_args = 3;
@@ -6188,7 +6194,7 @@ inline bool CallContext::_internal_correct_order_of_args() const {
   return _impl_.correct_order_of_args_;
 }
 inline bool CallContext::correct_order_of_args() const {
-  // @@protoc_insertion_point(field_get:CallContext.correct_order_of_args)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CallContext.correct_order_of_args)
   return _internal_correct_order_of_args();
 }
 inline void CallContext::_internal_set_correct_order_of_args(bool value) {
@@ -6197,7 +6203,7 @@ inline void CallContext::_internal_set_correct_order_of_args(bool value) {
 }
 inline void CallContext::set_correct_order_of_args(bool value) {
   _internal_set_correct_order_of_args(value);
-  // @@protoc_insertion_point(field_set:CallContext.correct_order_of_args)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallContext.correct_order_of_args)
 }
 
 // bool no_missing_args = 4;
@@ -6208,7 +6214,7 @@ inline bool CallContext::_internal_no_missing_args() const {
   return _impl_.no_missing_args_;
 }
 inline bool CallContext::no_missing_args() const {
-  // @@protoc_insertion_point(field_get:CallContext.no_missing_args)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CallContext.no_missing_args)
   return _internal_no_missing_args();
 }
 inline void CallContext::_internal_set_no_missing_args(bool value) {
@@ -6217,7 +6223,7 @@ inline void CallContext::_internal_set_no_missing_args(bool value) {
 }
 inline void CallContext::set_no_missing_args(bool value) {
   _internal_set_no_missing_args(value);
-  // @@protoc_insertion_point(field_set:CallContext.no_missing_args)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallContext.no_missing_args)
 }
 
 // -------------------------------------------------------------------
@@ -6232,7 +6238,7 @@ inline bool ArgumentContext::_internal_eager() const {
   return _impl_.eager_;
 }
 inline bool ArgumentContext::eager() const {
-  // @@protoc_insertion_point(field_get:ArgumentContext.eager)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ArgumentContext.eager)
   return _internal_eager();
 }
 inline void ArgumentContext::_internal_set_eager(bool value) {
@@ -6241,7 +6247,7 @@ inline void ArgumentContext::_internal_set_eager(bool value) {
 }
 inline void ArgumentContext::set_eager(bool value) {
   _internal_set_eager(value);
-  // @@protoc_insertion_point(field_set:ArgumentContext.eager)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ArgumentContext.eager)
 }
 
 // bool reflection = 2;
@@ -6252,7 +6258,7 @@ inline bool ArgumentContext::_internal_reflection() const {
   return _impl_.reflection_;
 }
 inline bool ArgumentContext::reflection() const {
-  // @@protoc_insertion_point(field_get:ArgumentContext.reflection)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ArgumentContext.reflection)
   return _internal_reflection();
 }
 inline void ArgumentContext::_internal_set_reflection(bool value) {
@@ -6261,7 +6267,7 @@ inline void ArgumentContext::_internal_set_reflection(bool value) {
 }
 inline void ArgumentContext::set_reflection(bool value) {
   _internal_set_reflection(value);
-  // @@protoc_insertion_point(field_set:ArgumentContext.reflection)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ArgumentContext.reflection)
 }
 
 // bool object = 3;
@@ -6272,7 +6278,7 @@ inline bool ArgumentContext::_internal_object() const {
   return _impl_.object_;
 }
 inline bool ArgumentContext::object() const {
-  // @@protoc_insertion_point(field_get:ArgumentContext.object)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ArgumentContext.object)
   return _internal_object();
 }
 inline void ArgumentContext::_internal_set_object(bool value) {
@@ -6281,10 +6287,10 @@ inline void ArgumentContext::_internal_set_object(bool value) {
 }
 inline void ArgumentContext::set_object(bool value) {
   _internal_set_object(value);
-  // @@protoc_insertion_point(field_set:ArgumentContext.object)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ArgumentContext.object)
 }
 
-// optional .Type type = 4;
+// optional .rsh.protocol.Type type = 4;
 inline bool ArgumentContext::_internal_has_type() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   return value;
@@ -6296,27 +6302,27 @@ inline void ArgumentContext::clear_type() {
   _impl_.type_ = 0;
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline ::Type ArgumentContext::_internal_type() const {
-  return static_cast< ::Type >(_impl_.type_);
+inline ::rsh::protocol::Type ArgumentContext::_internal_type() const {
+  return static_cast< ::rsh::protocol::Type >(_impl_.type_);
 }
-inline ::Type ArgumentContext::type() const {
-  // @@protoc_insertion_point(field_get:ArgumentContext.type)
+inline ::rsh::protocol::Type ArgumentContext::type() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.ArgumentContext.type)
   return _internal_type();
 }
-inline void ArgumentContext::_internal_set_type(::Type value) {
+inline void ArgumentContext::_internal_set_type(::rsh::protocol::Type value) {
   _impl_._has_bits_[0] |= 0x00000001u;
   _impl_.type_ = value;
 }
-inline void ArgumentContext::set_type(::Type value) {
+inline void ArgumentContext::set_type(::rsh::protocol::Type value) {
   _internal_set_type(value);
-  // @@protoc_insertion_point(field_set:ArgumentContext.type)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ArgumentContext.type)
 }
 
 // -------------------------------------------------------------------
 
 // Context
 
-// .CallContext call_context = 1;
+// .rsh.protocol.CallContext call_context = 1;
 inline bool Context::_internal_has_call_context() const {
   return this != internal_default_instance() && _impl_.call_context_ != nullptr;
 }
@@ -6329,17 +6335,17 @@ inline void Context::clear_call_context() {
   }
   _impl_.call_context_ = nullptr;
 }
-inline const ::CallContext& Context::_internal_call_context() const {
-  const ::CallContext* p = _impl_.call_context_;
-  return p != nullptr ? *p : reinterpret_cast<const ::CallContext&>(
-      ::_CallContext_default_instance_);
+inline const ::rsh::protocol::CallContext& Context::_internal_call_context() const {
+  const ::rsh::protocol::CallContext* p = _impl_.call_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::CallContext&>(
+      ::rsh::protocol::_CallContext_default_instance_);
 }
-inline const ::CallContext& Context::call_context() const {
-  // @@protoc_insertion_point(field_get:Context.call_context)
+inline const ::rsh::protocol::CallContext& Context::call_context() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.Context.call_context)
   return _internal_call_context();
 }
 inline void Context::unsafe_arena_set_allocated_call_context(
-    ::CallContext* call_context) {
+    ::rsh::protocol::CallContext* call_context) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.call_context_);
   }
@@ -6349,11 +6355,11 @@ inline void Context::unsafe_arena_set_allocated_call_context(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Context.call_context)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.Context.call_context)
 }
-inline ::CallContext* Context::release_call_context() {
+inline ::rsh::protocol::CallContext* Context::release_call_context() {
   
-  ::CallContext* temp = _impl_.call_context_;
+  ::rsh::protocol::CallContext* temp = _impl_.call_context_;
   _impl_.call_context_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -6366,27 +6372,27 @@ inline ::CallContext* Context::release_call_context() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::CallContext* Context::unsafe_arena_release_call_context() {
-  // @@protoc_insertion_point(field_release:Context.call_context)
+inline ::rsh::protocol::CallContext* Context::unsafe_arena_release_call_context() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.Context.call_context)
   
-  ::CallContext* temp = _impl_.call_context_;
+  ::rsh::protocol::CallContext* temp = _impl_.call_context_;
   _impl_.call_context_ = nullptr;
   return temp;
 }
-inline ::CallContext* Context::_internal_mutable_call_context() {
+inline ::rsh::protocol::CallContext* Context::_internal_mutable_call_context() {
   
   if (_impl_.call_context_ == nullptr) {
-    auto* p = CreateMaybeMessage<::CallContext>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::CallContext>(GetArenaForAllocation());
     _impl_.call_context_ = p;
   }
   return _impl_.call_context_;
 }
-inline ::CallContext* Context::mutable_call_context() {
-  ::CallContext* _msg = _internal_mutable_call_context();
-  // @@protoc_insertion_point(field_mutable:Context.call_context)
+inline ::rsh::protocol::CallContext* Context::mutable_call_context() {
+  ::rsh::protocol::CallContext* _msg = _internal_mutable_call_context();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Context.call_context)
   return _msg;
 }
-inline void Context::set_allocated_call_context(::CallContext* call_context) {
+inline void Context::set_allocated_call_context(::rsh::protocol::CallContext* call_context) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.call_context_;
@@ -6403,10 +6409,10 @@ inline void Context::set_allocated_call_context(::CallContext* call_context) {
     
   }
   _impl_.call_context_ = call_context;
-  // @@protoc_insertion_point(field_set_allocated:Context.call_context)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Context.call_context)
 }
 
-// repeated .ArgumentContext argument_context = 2;
+// repeated .rsh.protocol.ArgumentContext argument_context = 2;
 inline int Context::_internal_argument_context_size() const {
   return _impl_.argument_context_.size();
 }
@@ -6416,33 +6422,33 @@ inline int Context::argument_context_size() const {
 inline void Context::clear_argument_context() {
   _impl_.argument_context_.Clear();
 }
-inline ::ArgumentContext* Context::mutable_argument_context(int index) {
-  // @@protoc_insertion_point(field_mutable:Context.argument_context)
+inline ::rsh::protocol::ArgumentContext* Context::mutable_argument_context(int index) {
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Context.argument_context)
   return _impl_.argument_context_.Mutable(index);
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >*
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::ArgumentContext >*
 Context::mutable_argument_context() {
-  // @@protoc_insertion_point(field_mutable_list:Context.argument_context)
+  // @@protoc_insertion_point(field_mutable_list:rsh.protocol.Context.argument_context)
   return &_impl_.argument_context_;
 }
-inline const ::ArgumentContext& Context::_internal_argument_context(int index) const {
+inline const ::rsh::protocol::ArgumentContext& Context::_internal_argument_context(int index) const {
   return _impl_.argument_context_.Get(index);
 }
-inline const ::ArgumentContext& Context::argument_context(int index) const {
-  // @@protoc_insertion_point(field_get:Context.argument_context)
+inline const ::rsh::protocol::ArgumentContext& Context::argument_context(int index) const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.Context.argument_context)
   return _internal_argument_context(index);
 }
-inline ::ArgumentContext* Context::_internal_add_argument_context() {
+inline ::rsh::protocol::ArgumentContext* Context::_internal_add_argument_context() {
   return _impl_.argument_context_.Add();
 }
-inline ::ArgumentContext* Context::add_argument_context() {
-  ::ArgumentContext* _add = _internal_add_argument_context();
-  // @@protoc_insertion_point(field_add:Context.argument_context)
+inline ::rsh::protocol::ArgumentContext* Context::add_argument_context() {
+  ::rsh::protocol::ArgumentContext* _add = _internal_add_argument_context();
+  // @@protoc_insertion_point(field_add:rsh.protocol.Context.argument_context)
   return _add;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ArgumentContext >&
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::rsh::protocol::ArgumentContext >&
 Context::argument_context() const {
-  // @@protoc_insertion_point(field_list:Context.argument_context)
+  // @@protoc_insertion_point(field_list:rsh.protocol.Context.argument_context)
   return _impl_.argument_context_;
 }
 
@@ -6450,7 +6456,7 @@ Context::argument_context() const {
 
 // ContextRequest
 
-// .Function function = 1;
+// .rsh.protocol.Function function = 1;
 inline bool ContextRequest::_internal_has_function() const {
   return this != internal_default_instance() && _impl_.function_ != nullptr;
 }
@@ -6463,17 +6469,17 @@ inline void ContextRequest::clear_function() {
   }
   _impl_.function_ = nullptr;
 }
-inline const ::Function& ContextRequest::_internal_function() const {
-  const ::Function* p = _impl_.function_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Function&>(
-      ::_Function_default_instance_);
+inline const ::rsh::protocol::Function& ContextRequest::_internal_function() const {
+  const ::rsh::protocol::Function* p = _impl_.function_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Function&>(
+      ::rsh::protocol::_Function_default_instance_);
 }
-inline const ::Function& ContextRequest::function() const {
-  // @@protoc_insertion_point(field_get:ContextRequest.function)
+inline const ::rsh::protocol::Function& ContextRequest::function() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.ContextRequest.function)
   return _internal_function();
 }
 inline void ContextRequest::unsafe_arena_set_allocated_function(
-    ::Function* function) {
+    ::rsh::protocol::Function* function) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_);
   }
@@ -6483,11 +6489,11 @@ inline void ContextRequest::unsafe_arena_set_allocated_function(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ContextRequest.function)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.ContextRequest.function)
 }
-inline ::Function* ContextRequest::release_function() {
+inline ::rsh::protocol::Function* ContextRequest::release_function() {
   
-  ::Function* temp = _impl_.function_;
+  ::rsh::protocol::Function* temp = _impl_.function_;
   _impl_.function_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -6500,27 +6506,27 @@ inline ::Function* ContextRequest::release_function() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Function* ContextRequest::unsafe_arena_release_function() {
-  // @@protoc_insertion_point(field_release:ContextRequest.function)
+inline ::rsh::protocol::Function* ContextRequest::unsafe_arena_release_function() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.ContextRequest.function)
   
-  ::Function* temp = _impl_.function_;
+  ::rsh::protocol::Function* temp = _impl_.function_;
   _impl_.function_ = nullptr;
   return temp;
 }
-inline ::Function* ContextRequest::_internal_mutable_function() {
+inline ::rsh::protocol::Function* ContextRequest::_internal_mutable_function() {
   
   if (_impl_.function_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Function>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Function>(GetArenaForAllocation());
     _impl_.function_ = p;
   }
   return _impl_.function_;
 }
-inline ::Function* ContextRequest::mutable_function() {
-  ::Function* _msg = _internal_mutable_function();
-  // @@protoc_insertion_point(field_mutable:ContextRequest.function)
+inline ::rsh::protocol::Function* ContextRequest::mutable_function() {
+  ::rsh::protocol::Function* _msg = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.ContextRequest.function)
   return _msg;
 }
-inline void ContextRequest::set_allocated_function(::Function* function) {
+inline void ContextRequest::set_allocated_function(::rsh::protocol::Function* function) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.function_;
@@ -6537,31 +6543,31 @@ inline void ContextRequest::set_allocated_function(::Function* function) {
     
   }
   _impl_.function_ = function;
-  // @@protoc_insertion_point(field_set_allocated:ContextRequest.function)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.ContextRequest.function)
 }
 
 // -------------------------------------------------------------------
 
 // TestFeedback
 
-// .TestLattice test_lattice = 1;
+// .rsh.protocol.TestLattice test_lattice = 1;
 inline void TestFeedback::clear_test_lattice() {
   _impl_.test_lattice_ = 0;
 }
-inline ::TestLattice TestFeedback::_internal_test_lattice() const {
-  return static_cast< ::TestLattice >(_impl_.test_lattice_);
+inline ::rsh::protocol::TestLattice TestFeedback::_internal_test_lattice() const {
+  return static_cast< ::rsh::protocol::TestLattice >(_impl_.test_lattice_);
 }
-inline ::TestLattice TestFeedback::test_lattice() const {
-  // @@protoc_insertion_point(field_get:TestFeedback.test_lattice)
+inline ::rsh::protocol::TestLattice TestFeedback::test_lattice() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.TestFeedback.test_lattice)
   return _internal_test_lattice();
 }
-inline void TestFeedback::_internal_set_test_lattice(::TestLattice value) {
+inline void TestFeedback::_internal_set_test_lattice(::rsh::protocol::TestLattice value) {
   
   _impl_.test_lattice_ = value;
 }
-inline void TestFeedback::set_test_lattice(::TestLattice value) {
+inline void TestFeedback::set_test_lattice(::rsh::protocol::TestLattice value) {
   _internal_set_test_lattice(value);
-  // @@protoc_insertion_point(field_set:TestFeedback.test_lattice)
+  // @@protoc_insertion_point(field_set:rsh.protocol.TestFeedback.test_lattice)
 }
 
 // -------------------------------------------------------------------
@@ -6576,7 +6582,7 @@ inline int64_t CallFeedback::_internal_n_calls() const {
   return _impl_.n_calls_;
 }
 inline int64_t CallFeedback::n_calls() const {
-  // @@protoc_insertion_point(field_get:CallFeedback.n_calls)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CallFeedback.n_calls)
   return _internal_n_calls();
 }
 inline void CallFeedback::_internal_set_n_calls(int64_t value) {
@@ -6585,7 +6591,7 @@ inline void CallFeedback::_internal_set_n_calls(int64_t value) {
 }
 inline void CallFeedback::set_n_calls(int64_t value) {
   _internal_set_n_calls(value);
-  // @@protoc_insertion_point(field_set:CallFeedback.n_calls)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallFeedback.n_calls)
 }
 
 // bytes callee_hash = 2;
@@ -6593,7 +6599,7 @@ inline void CallFeedback::clear_callee_hash() {
   _impl_.callee_hash_.ClearToEmpty();
 }
 inline const std::string& CallFeedback::callee_hash() const {
-  // @@protoc_insertion_point(field_get:CallFeedback.callee_hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.CallFeedback.callee_hash)
   return _internal_callee_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -6601,11 +6607,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void CallFeedback::set_callee_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.callee_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:CallFeedback.callee_hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallFeedback.callee_hash)
 }
 inline std::string* CallFeedback::mutable_callee_hash() {
   std::string* _s = _internal_mutable_callee_hash();
-  // @@protoc_insertion_point(field_mutable:CallFeedback.callee_hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CallFeedback.callee_hash)
   return _s;
 }
 inline const std::string& CallFeedback::_internal_callee_hash() const {
@@ -6620,7 +6626,7 @@ inline std::string* CallFeedback::_internal_mutable_callee_hash() {
   return _impl_.callee_hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* CallFeedback::release_callee_hash() {
-  // @@protoc_insertion_point(field_release:CallFeedback.callee_hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.CallFeedback.callee_hash)
   return _impl_.callee_hash_.Release();
 }
 inline void CallFeedback::set_allocated_callee_hash(std::string* callee_hash) {
@@ -6635,7 +6641,7 @@ inline void CallFeedback::set_allocated_callee_hash(std::string* callee_hash) {
     _impl_.callee_hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:CallFeedback.callee_hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CallFeedback.callee_hash)
 }
 
 // -------------------------------------------------------------------
@@ -6650,7 +6656,7 @@ inline bool ValueFeedback::_internal_scalar() const {
   return _impl_.scalar_;
 }
 inline bool ValueFeedback::scalar() const {
-  // @@protoc_insertion_point(field_get:ValueFeedback.scalar)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ValueFeedback.scalar)
   return _internal_scalar();
 }
 inline void ValueFeedback::_internal_set_scalar(bool value) {
@@ -6659,7 +6665,7 @@ inline void ValueFeedback::_internal_set_scalar(bool value) {
 }
 inline void ValueFeedback::set_scalar(bool value) {
   _internal_set_scalar(value);
-  // @@protoc_insertion_point(field_set:ValueFeedback.scalar)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueFeedback.scalar)
 }
 
 // bool object = 2;
@@ -6670,7 +6676,7 @@ inline bool ValueFeedback::_internal_object() const {
   return _impl_.object_;
 }
 inline bool ValueFeedback::object() const {
-  // @@protoc_insertion_point(field_get:ValueFeedback.object)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ValueFeedback.object)
   return _internal_object();
 }
 inline void ValueFeedback::_internal_set_object(bool value) {
@@ -6679,7 +6685,7 @@ inline void ValueFeedback::_internal_set_object(bool value) {
 }
 inline void ValueFeedback::set_object(bool value) {
   _internal_set_object(value);
-  // @@protoc_insertion_point(field_set:ValueFeedback.object)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueFeedback.object)
 }
 
 // bool accessed_attributes = 3;
@@ -6690,7 +6696,7 @@ inline bool ValueFeedback::_internal_accessed_attributes() const {
   return _impl_.accessed_attributes_;
 }
 inline bool ValueFeedback::accessed_attributes() const {
-  // @@protoc_insertion_point(field_get:ValueFeedback.accessed_attributes)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ValueFeedback.accessed_attributes)
   return _internal_accessed_attributes();
 }
 inline void ValueFeedback::_internal_set_accessed_attributes(bool value) {
@@ -6699,7 +6705,7 @@ inline void ValueFeedback::_internal_set_accessed_attributes(bool value) {
 }
 inline void ValueFeedback::set_accessed_attributes(bool value) {
   _internal_set_accessed_attributes(value);
-  // @@protoc_insertion_point(field_set:ValueFeedback.accessed_attributes)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueFeedback.accessed_attributes)
 }
 
 // bool vectorizable = 4;
@@ -6710,7 +6716,7 @@ inline bool ValueFeedback::_internal_vectorizable() const {
   return _impl_.vectorizable_;
 }
 inline bool ValueFeedback::vectorizable() const {
-  // @@protoc_insertion_point(field_get:ValueFeedback.vectorizable)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ValueFeedback.vectorizable)
   return _internal_vectorizable();
 }
 inline void ValueFeedback::_internal_set_vectorizable(bool value) {
@@ -6719,7 +6725,7 @@ inline void ValueFeedback::_internal_set_vectorizable(bool value) {
 }
 inline void ValueFeedback::set_vectorizable(bool value) {
   _internal_set_vectorizable(value);
-  // @@protoc_insertion_point(field_set:ValueFeedback.vectorizable)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueFeedback.vectorizable)
 }
 
 // bool is_promise = 5;
@@ -6730,7 +6736,7 @@ inline bool ValueFeedback::_internal_is_promise() const {
   return _impl_.is_promise_;
 }
 inline bool ValueFeedback::is_promise() const {
-  // @@protoc_insertion_point(field_get:ValueFeedback.is_promise)
+  // @@protoc_insertion_point(field_get:rsh.protocol.ValueFeedback.is_promise)
   return _internal_is_promise();
 }
 inline void ValueFeedback::_internal_set_is_promise(bool value) {
@@ -6739,14 +6745,14 @@ inline void ValueFeedback::_internal_set_is_promise(bool value) {
 }
 inline void ValueFeedback::set_is_promise(bool value) {
   _internal_set_is_promise(value);
-  // @@protoc_insertion_point(field_set:ValueFeedback.is_promise)
+  // @@protoc_insertion_point(field_set:rsh.protocol.ValueFeedback.is_promise)
 }
 
 // -------------------------------------------------------------------
 
 // TypeFeedback_Feedback
 
-// .TestFeedback test_feedback = 1;
+// .rsh.protocol.TestFeedback test_feedback = 1;
 inline bool TypeFeedback_Feedback::_internal_has_test_feedback() const {
   return feedback_case() == kTestFeedback;
 }
@@ -6764,11 +6770,11 @@ inline void TypeFeedback_Feedback::clear_test_feedback() {
     clear_has_feedback();
   }
 }
-inline ::TestFeedback* TypeFeedback_Feedback::release_test_feedback() {
-  // @@protoc_insertion_point(field_release:TypeFeedback.Feedback.test_feedback)
+inline ::rsh::protocol::TestFeedback* TypeFeedback_Feedback::release_test_feedback() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.TypeFeedback.Feedback.test_feedback)
   if (_internal_has_test_feedback()) {
     clear_has_feedback();
-    ::TestFeedback* temp = _impl_.feedback_.test_feedback_;
+    ::rsh::protocol::TestFeedback* temp = _impl_.feedback_.test_feedback_;
     if (GetArenaForAllocation() != nullptr) {
       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
     }
@@ -6778,49 +6784,49 @@ inline ::TestFeedback* TypeFeedback_Feedback::release_test_feedback() {
     return nullptr;
   }
 }
-inline const ::TestFeedback& TypeFeedback_Feedback::_internal_test_feedback() const {
+inline const ::rsh::protocol::TestFeedback& TypeFeedback_Feedback::_internal_test_feedback() const {
   return _internal_has_test_feedback()
       ? *_impl_.feedback_.test_feedback_
-      : reinterpret_cast< ::TestFeedback&>(::_TestFeedback_default_instance_);
+      : reinterpret_cast< ::rsh::protocol::TestFeedback&>(::rsh::protocol::_TestFeedback_default_instance_);
 }
-inline const ::TestFeedback& TypeFeedback_Feedback::test_feedback() const {
-  // @@protoc_insertion_point(field_get:TypeFeedback.Feedback.test_feedback)
+inline const ::rsh::protocol::TestFeedback& TypeFeedback_Feedback::test_feedback() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.TypeFeedback.Feedback.test_feedback)
   return _internal_test_feedback();
 }
-inline ::TestFeedback* TypeFeedback_Feedback::unsafe_arena_release_test_feedback() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:TypeFeedback.Feedback.test_feedback)
+inline ::rsh::protocol::TestFeedback* TypeFeedback_Feedback::unsafe_arena_release_test_feedback() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.protocol.TypeFeedback.Feedback.test_feedback)
   if (_internal_has_test_feedback()) {
     clear_has_feedback();
-    ::TestFeedback* temp = _impl_.feedback_.test_feedback_;
+    ::rsh::protocol::TestFeedback* temp = _impl_.feedback_.test_feedback_;
     _impl_.feedback_.test_feedback_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
-inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_test_feedback(::TestFeedback* test_feedback) {
+inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_test_feedback(::rsh::protocol::TestFeedback* test_feedback) {
   clear_feedback();
   if (test_feedback) {
     set_has_test_feedback();
     _impl_.feedback_.test_feedback_ = test_feedback;
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:TypeFeedback.Feedback.test_feedback)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.TypeFeedback.Feedback.test_feedback)
 }
-inline ::TestFeedback* TypeFeedback_Feedback::_internal_mutable_test_feedback() {
+inline ::rsh::protocol::TestFeedback* TypeFeedback_Feedback::_internal_mutable_test_feedback() {
   if (!_internal_has_test_feedback()) {
     clear_feedback();
     set_has_test_feedback();
-    _impl_.feedback_.test_feedback_ = CreateMaybeMessage< ::TestFeedback >(GetArenaForAllocation());
+    _impl_.feedback_.test_feedback_ = CreateMaybeMessage< ::rsh::protocol::TestFeedback >(GetArenaForAllocation());
   }
   return _impl_.feedback_.test_feedback_;
 }
-inline ::TestFeedback* TypeFeedback_Feedback::mutable_test_feedback() {
-  ::TestFeedback* _msg = _internal_mutable_test_feedback();
-  // @@protoc_insertion_point(field_mutable:TypeFeedback.Feedback.test_feedback)
+inline ::rsh::protocol::TestFeedback* TypeFeedback_Feedback::mutable_test_feedback() {
+  ::rsh::protocol::TestFeedback* _msg = _internal_mutable_test_feedback();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.TypeFeedback.Feedback.test_feedback)
   return _msg;
 }
 
-// .CallFeedback call_feedback = 2;
+// .rsh.protocol.CallFeedback call_feedback = 2;
 inline bool TypeFeedback_Feedback::_internal_has_call_feedback() const {
   return feedback_case() == kCallFeedback;
 }
@@ -6838,11 +6844,11 @@ inline void TypeFeedback_Feedback::clear_call_feedback() {
     clear_has_feedback();
   }
 }
-inline ::CallFeedback* TypeFeedback_Feedback::release_call_feedback() {
-  // @@protoc_insertion_point(field_release:TypeFeedback.Feedback.call_feedback)
+inline ::rsh::protocol::CallFeedback* TypeFeedback_Feedback::release_call_feedback() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.TypeFeedback.Feedback.call_feedback)
   if (_internal_has_call_feedback()) {
     clear_has_feedback();
-    ::CallFeedback* temp = _impl_.feedback_.call_feedback_;
+    ::rsh::protocol::CallFeedback* temp = _impl_.feedback_.call_feedback_;
     if (GetArenaForAllocation() != nullptr) {
       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
     }
@@ -6852,49 +6858,49 @@ inline ::CallFeedback* TypeFeedback_Feedback::release_call_feedback() {
     return nullptr;
   }
 }
-inline const ::CallFeedback& TypeFeedback_Feedback::_internal_call_feedback() const {
+inline const ::rsh::protocol::CallFeedback& TypeFeedback_Feedback::_internal_call_feedback() const {
   return _internal_has_call_feedback()
       ? *_impl_.feedback_.call_feedback_
-      : reinterpret_cast< ::CallFeedback&>(::_CallFeedback_default_instance_);
+      : reinterpret_cast< ::rsh::protocol::CallFeedback&>(::rsh::protocol::_CallFeedback_default_instance_);
 }
-inline const ::CallFeedback& TypeFeedback_Feedback::call_feedback() const {
-  // @@protoc_insertion_point(field_get:TypeFeedback.Feedback.call_feedback)
+inline const ::rsh::protocol::CallFeedback& TypeFeedback_Feedback::call_feedback() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.TypeFeedback.Feedback.call_feedback)
   return _internal_call_feedback();
 }
-inline ::CallFeedback* TypeFeedback_Feedback::unsafe_arena_release_call_feedback() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:TypeFeedback.Feedback.call_feedback)
+inline ::rsh::protocol::CallFeedback* TypeFeedback_Feedback::unsafe_arena_release_call_feedback() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.protocol.TypeFeedback.Feedback.call_feedback)
   if (_internal_has_call_feedback()) {
     clear_has_feedback();
-    ::CallFeedback* temp = _impl_.feedback_.call_feedback_;
+    ::rsh::protocol::CallFeedback* temp = _impl_.feedback_.call_feedback_;
     _impl_.feedback_.call_feedback_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
-inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_call_feedback(::CallFeedback* call_feedback) {
+inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_call_feedback(::rsh::protocol::CallFeedback* call_feedback) {
   clear_feedback();
   if (call_feedback) {
     set_has_call_feedback();
     _impl_.feedback_.call_feedback_ = call_feedback;
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:TypeFeedback.Feedback.call_feedback)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.TypeFeedback.Feedback.call_feedback)
 }
-inline ::CallFeedback* TypeFeedback_Feedback::_internal_mutable_call_feedback() {
+inline ::rsh::protocol::CallFeedback* TypeFeedback_Feedback::_internal_mutable_call_feedback() {
   if (!_internal_has_call_feedback()) {
     clear_feedback();
     set_has_call_feedback();
-    _impl_.feedback_.call_feedback_ = CreateMaybeMessage< ::CallFeedback >(GetArenaForAllocation());
+    _impl_.feedback_.call_feedback_ = CreateMaybeMessage< ::rsh::protocol::CallFeedback >(GetArenaForAllocation());
   }
   return _impl_.feedback_.call_feedback_;
 }
-inline ::CallFeedback* TypeFeedback_Feedback::mutable_call_feedback() {
-  ::CallFeedback* _msg = _internal_mutable_call_feedback();
-  // @@protoc_insertion_point(field_mutable:TypeFeedback.Feedback.call_feedback)
+inline ::rsh::protocol::CallFeedback* TypeFeedback_Feedback::mutable_call_feedback() {
+  ::rsh::protocol::CallFeedback* _msg = _internal_mutable_call_feedback();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.TypeFeedback.Feedback.call_feedback)
   return _msg;
 }
 
-// .ValueFeedback value_feedback = 3;
+// .rsh.protocol.ValueFeedback value_feedback = 3;
 inline bool TypeFeedback_Feedback::_internal_has_value_feedback() const {
   return feedback_case() == kValueFeedback;
 }
@@ -6912,11 +6918,11 @@ inline void TypeFeedback_Feedback::clear_value_feedback() {
     clear_has_feedback();
   }
 }
-inline ::ValueFeedback* TypeFeedback_Feedback::release_value_feedback() {
-  // @@protoc_insertion_point(field_release:TypeFeedback.Feedback.value_feedback)
+inline ::rsh::protocol::ValueFeedback* TypeFeedback_Feedback::release_value_feedback() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.TypeFeedback.Feedback.value_feedback)
   if (_internal_has_value_feedback()) {
     clear_has_feedback();
-    ::ValueFeedback* temp = _impl_.feedback_.value_feedback_;
+    ::rsh::protocol::ValueFeedback* temp = _impl_.feedback_.value_feedback_;
     if (GetArenaForAllocation() != nullptr) {
       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
     }
@@ -6926,45 +6932,45 @@ inline ::ValueFeedback* TypeFeedback_Feedback::release_value_feedback() {
     return nullptr;
   }
 }
-inline const ::ValueFeedback& TypeFeedback_Feedback::_internal_value_feedback() const {
+inline const ::rsh::protocol::ValueFeedback& TypeFeedback_Feedback::_internal_value_feedback() const {
   return _internal_has_value_feedback()
       ? *_impl_.feedback_.value_feedback_
-      : reinterpret_cast< ::ValueFeedback&>(::_ValueFeedback_default_instance_);
+      : reinterpret_cast< ::rsh::protocol::ValueFeedback&>(::rsh::protocol::_ValueFeedback_default_instance_);
 }
-inline const ::ValueFeedback& TypeFeedback_Feedback::value_feedback() const {
-  // @@protoc_insertion_point(field_get:TypeFeedback.Feedback.value_feedback)
+inline const ::rsh::protocol::ValueFeedback& TypeFeedback_Feedback::value_feedback() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.TypeFeedback.Feedback.value_feedback)
   return _internal_value_feedback();
 }
-inline ::ValueFeedback* TypeFeedback_Feedback::unsafe_arena_release_value_feedback() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:TypeFeedback.Feedback.value_feedback)
+inline ::rsh::protocol::ValueFeedback* TypeFeedback_Feedback::unsafe_arena_release_value_feedback() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.protocol.TypeFeedback.Feedback.value_feedback)
   if (_internal_has_value_feedback()) {
     clear_has_feedback();
-    ::ValueFeedback* temp = _impl_.feedback_.value_feedback_;
+    ::rsh::protocol::ValueFeedback* temp = _impl_.feedback_.value_feedback_;
     _impl_.feedback_.value_feedback_ = nullptr;
     return temp;
   } else {
     return nullptr;
   }
 }
-inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_value_feedback(::ValueFeedback* value_feedback) {
+inline void TypeFeedback_Feedback::unsafe_arena_set_allocated_value_feedback(::rsh::protocol::ValueFeedback* value_feedback) {
   clear_feedback();
   if (value_feedback) {
     set_has_value_feedback();
     _impl_.feedback_.value_feedback_ = value_feedback;
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:TypeFeedback.Feedback.value_feedback)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.TypeFeedback.Feedback.value_feedback)
 }
-inline ::ValueFeedback* TypeFeedback_Feedback::_internal_mutable_value_feedback() {
+inline ::rsh::protocol::ValueFeedback* TypeFeedback_Feedback::_internal_mutable_value_feedback() {
   if (!_internal_has_value_feedback()) {
     clear_feedback();
     set_has_value_feedback();
-    _impl_.feedback_.value_feedback_ = CreateMaybeMessage< ::ValueFeedback >(GetArenaForAllocation());
+    _impl_.feedback_.value_feedback_ = CreateMaybeMessage< ::rsh::protocol::ValueFeedback >(GetArenaForAllocation());
   }
   return _impl_.feedback_.value_feedback_;
 }
-inline ::ValueFeedback* TypeFeedback_Feedback::mutable_value_feedback() {
-  ::ValueFeedback* _msg = _internal_mutable_value_feedback();
-  // @@protoc_insertion_point(field_mutable:TypeFeedback.Feedback.value_feedback)
+inline ::rsh::protocol::ValueFeedback* TypeFeedback_Feedback::mutable_value_feedback() {
+  ::rsh::protocol::ValueFeedback* _msg = _internal_mutable_value_feedback();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.TypeFeedback.Feedback.value_feedback)
   return _msg;
 }
 
@@ -6983,7 +6989,7 @@ inline TypeFeedback_Feedback::FeedbackCase TypeFeedback_Feedback::feedback_case(
 
 // TypeFeedback
 
-// map<int64, .TypeFeedback.Feedback> types = 2;
+// map<int64, .rsh.protocol.TypeFeedback.Feedback> types = 2;
 inline int TypeFeedback::_internal_types_size() const {
   return _impl_.types_.size();
 }
@@ -6993,22 +6999,22 @@ inline int TypeFeedback::types_size() const {
 inline void TypeFeedback::clear_types() {
   _impl_.types_.Clear();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >&
 TypeFeedback::_internal_types() const {
   return _impl_.types_.GetMap();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >&
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >&
 TypeFeedback::types() const {
-  // @@protoc_insertion_point(field_map:TypeFeedback.types)
+  // @@protoc_insertion_point(field_map:rsh.protocol.TypeFeedback.types)
   return _internal_types();
 }
-inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >*
 TypeFeedback::_internal_mutable_types() {
   return _impl_.types_.MutableMap();
 }
-inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::TypeFeedback_Feedback >*
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::rsh::protocol::TypeFeedback_Feedback >*
 TypeFeedback::mutable_types() {
-  // @@protoc_insertion_point(field_mutable_map:TypeFeedback.types)
+  // @@protoc_insertion_point(field_mutable_map:rsh.protocol.TypeFeedback.types)
   return _internal_mutable_types();
 }
 
@@ -7016,7 +7022,7 @@ TypeFeedback::mutable_types() {
 
 // FeedbackRequest
 
-// .Function function = 1;
+// .rsh.protocol.Function function = 1;
 inline bool FeedbackRequest::_internal_has_function() const {
   return this != internal_default_instance() && _impl_.function_ != nullptr;
 }
@@ -7029,17 +7035,17 @@ inline void FeedbackRequest::clear_function() {
   }
   _impl_.function_ = nullptr;
 }
-inline const ::Function& FeedbackRequest::_internal_function() const {
-  const ::Function* p = _impl_.function_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Function&>(
-      ::_Function_default_instance_);
+inline const ::rsh::protocol::Function& FeedbackRequest::_internal_function() const {
+  const ::rsh::protocol::Function* p = _impl_.function_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Function&>(
+      ::rsh::protocol::_Function_default_instance_);
 }
-inline const ::Function& FeedbackRequest::function() const {
-  // @@protoc_insertion_point(field_get:FeedbackRequest.function)
+inline const ::rsh::protocol::Function& FeedbackRequest::function() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.FeedbackRequest.function)
   return _internal_function();
 }
 inline void FeedbackRequest::unsafe_arena_set_allocated_function(
-    ::Function* function) {
+    ::rsh::protocol::Function* function) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_);
   }
@@ -7049,11 +7055,11 @@ inline void FeedbackRequest::unsafe_arena_set_allocated_function(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FeedbackRequest.function)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.FeedbackRequest.function)
 }
-inline ::Function* FeedbackRequest::release_function() {
+inline ::rsh::protocol::Function* FeedbackRequest::release_function() {
   
-  ::Function* temp = _impl_.function_;
+  ::rsh::protocol::Function* temp = _impl_.function_;
   _impl_.function_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -7066,27 +7072,27 @@ inline ::Function* FeedbackRequest::release_function() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Function* FeedbackRequest::unsafe_arena_release_function() {
-  // @@protoc_insertion_point(field_release:FeedbackRequest.function)
+inline ::rsh::protocol::Function* FeedbackRequest::unsafe_arena_release_function() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.FeedbackRequest.function)
   
-  ::Function* temp = _impl_.function_;
+  ::rsh::protocol::Function* temp = _impl_.function_;
   _impl_.function_ = nullptr;
   return temp;
 }
-inline ::Function* FeedbackRequest::_internal_mutable_function() {
+inline ::rsh::protocol::Function* FeedbackRequest::_internal_mutable_function() {
   
   if (_impl_.function_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Function>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Function>(GetArenaForAllocation());
     _impl_.function_ = p;
   }
   return _impl_.function_;
 }
-inline ::Function* FeedbackRequest::mutable_function() {
-  ::Function* _msg = _internal_mutable_function();
-  // @@protoc_insertion_point(field_mutable:FeedbackRequest.function)
+inline ::rsh::protocol::Function* FeedbackRequest::mutable_function() {
+  ::rsh::protocol::Function* _msg = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.FeedbackRequest.function)
   return _msg;
 }
-inline void FeedbackRequest::set_allocated_function(::Function* function) {
+inline void FeedbackRequest::set_allocated_function(::rsh::protocol::Function* function) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.function_;
@@ -7103,7 +7109,7 @@ inline void FeedbackRequest::set_allocated_function(::Function* function) {
     
   }
   _impl_.function_ = function;
-  // @@protoc_insertion_point(field_set_allocated:FeedbackRequest.function)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.FeedbackRequest.function)
 }
 
 // -------------------------------------------------------------------
@@ -7127,7 +7133,7 @@ inline void PackageSource::clear_r_mirror() {
   }
 }
 inline const std::string& PackageSource::r_mirror() const {
-  // @@protoc_insertion_point(field_get:PackageSource.r_mirror)
+  // @@protoc_insertion_point(field_get:rsh.protocol.PackageSource.r_mirror)
   return _internal_r_mirror();
 }
 template <typename ArgT0, typename... ArgT>
@@ -7138,11 +7144,11 @@ inline void PackageSource::set_r_mirror(ArgT0&& arg0, ArgT... args) {
     _impl_.source_.r_mirror_.InitDefault();
   }
   _impl_.source_.r_mirror_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:PackageSource.r_mirror)
+  // @@protoc_insertion_point(field_set:rsh.protocol.PackageSource.r_mirror)
 }
 inline std::string* PackageSource::mutable_r_mirror() {
   std::string* _s = _internal_mutable_r_mirror();
-  // @@protoc_insertion_point(field_mutable:PackageSource.r_mirror)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.PackageSource.r_mirror)
   return _s;
 }
 inline const std::string& PackageSource::_internal_r_mirror() const {
@@ -7168,7 +7174,7 @@ inline std::string* PackageSource::_internal_mutable_r_mirror() {
   return _impl_.source_.r_mirror_.Mutable(      GetArenaForAllocation());
 }
 inline std::string* PackageSource::release_r_mirror() {
-  // @@protoc_insertion_point(field_release:PackageSource.r_mirror)
+  // @@protoc_insertion_point(field_release:rsh.protocol.PackageSource.r_mirror)
   if (_internal_has_r_mirror()) {
     clear_has_source();
     return _impl_.source_.r_mirror_.Release();
@@ -7184,7 +7190,7 @@ inline void PackageSource::set_allocated_r_mirror(std::string* r_mirror) {
     set_has_r_mirror();
     _impl_.source_.r_mirror_.InitAllocated(r_mirror, GetArenaForAllocation());
   }
-  // @@protoc_insertion_point(field_set_allocated:PackageSource.r_mirror)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.PackageSource.r_mirror)
 }
 
 // string github_url = 3;
@@ -7204,7 +7210,7 @@ inline void PackageSource::clear_github_url() {
   }
 }
 inline const std::string& PackageSource::github_url() const {
-  // @@protoc_insertion_point(field_get:PackageSource.github_url)
+  // @@protoc_insertion_point(field_get:rsh.protocol.PackageSource.github_url)
   return _internal_github_url();
 }
 template <typename ArgT0, typename... ArgT>
@@ -7215,11 +7221,11 @@ inline void PackageSource::set_github_url(ArgT0&& arg0, ArgT... args) {
     _impl_.source_.github_url_.InitDefault();
   }
   _impl_.source_.github_url_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:PackageSource.github_url)
+  // @@protoc_insertion_point(field_set:rsh.protocol.PackageSource.github_url)
 }
 inline std::string* PackageSource::mutable_github_url() {
   std::string* _s = _internal_mutable_github_url();
-  // @@protoc_insertion_point(field_mutable:PackageSource.github_url)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.PackageSource.github_url)
   return _s;
 }
 inline const std::string& PackageSource::_internal_github_url() const {
@@ -7245,7 +7251,7 @@ inline std::string* PackageSource::_internal_mutable_github_url() {
   return _impl_.source_.github_url_.Mutable(      GetArenaForAllocation());
 }
 inline std::string* PackageSource::release_github_url() {
-  // @@protoc_insertion_point(field_release:PackageSource.github_url)
+  // @@protoc_insertion_point(field_release:rsh.protocol.PackageSource.github_url)
   if (_internal_has_github_url()) {
     clear_has_source();
     return _impl_.source_.github_url_.Release();
@@ -7261,7 +7267,7 @@ inline void PackageSource::set_allocated_github_url(std::string* github_url) {
     set_has_github_url();
     _impl_.source_.github_url_.InitAllocated(github_url, GetArenaForAllocation());
   }
-  // @@protoc_insertion_point(field_set_allocated:PackageSource.github_url)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.PackageSource.github_url)
 }
 
 inline bool PackageSource::has_source() const {
@@ -7282,7 +7288,7 @@ inline void Package::clear_name() {
   _impl_.name_.ClearToEmpty();
 }
 inline const std::string& Package::name() const {
-  // @@protoc_insertion_point(field_get:Package.name)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Package.name)
   return _internal_name();
 }
 template <typename ArgT0, typename... ArgT>
@@ -7290,11 +7296,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void Package::set_name(ArgT0&& arg0, ArgT... args) {
  
  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:Package.name)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Package.name)
 }
 inline std::string* Package::mutable_name() {
   std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:Package.name)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Package.name)
   return _s;
 }
 inline const std::string& Package::_internal_name() const {
@@ -7309,7 +7315,7 @@ inline std::string* Package::_internal_mutable_name() {
   return _impl_.name_.Mutable(GetArenaForAllocation());
 }
 inline std::string* Package::release_name() {
-  // @@protoc_insertion_point(field_release:Package.name)
+  // @@protoc_insertion_point(field_release:rsh.protocol.Package.name)
   return _impl_.name_.Release();
 }
 inline void Package::set_allocated_name(std::string* name) {
@@ -7324,10 +7330,10 @@ inline void Package::set_allocated_name(std::string* name) {
     _impl_.name_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:Package.name)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Package.name)
 }
 
-// .Version version = 2;
+// .rsh.protocol.Version version = 2;
 inline bool Package::_internal_has_version() const {
   return this != internal_default_instance() && _impl_.version_ != nullptr;
 }
@@ -7340,17 +7346,17 @@ inline void Package::clear_version() {
   }
   _impl_.version_ = nullptr;
 }
-inline const ::Version& Package::_internal_version() const {
-  const ::Version* p = _impl_.version_;
-  return p != nullptr ? *p : reinterpret_cast<const ::Version&>(
-      ::_Version_default_instance_);
+inline const ::rsh::protocol::Version& Package::_internal_version() const {
+  const ::rsh::protocol::Version* p = _impl_.version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::Version&>(
+      ::rsh::protocol::_Version_default_instance_);
 }
-inline const ::Version& Package::version() const {
-  // @@protoc_insertion_point(field_get:Package.version)
+inline const ::rsh::protocol::Version& Package::version() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.Package.version)
   return _internal_version();
 }
 inline void Package::unsafe_arena_set_allocated_version(
-    ::Version* version) {
+    ::rsh::protocol::Version* version) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
   }
@@ -7360,11 +7366,11 @@ inline void Package::unsafe_arena_set_allocated_version(
   } else {
     
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Package.version)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.Package.version)
 }
-inline ::Version* Package::release_version() {
+inline ::rsh::protocol::Version* Package::release_version() {
   
-  ::Version* temp = _impl_.version_;
+  ::rsh::protocol::Version* temp = _impl_.version_;
   _impl_.version_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -7377,27 +7383,27 @@ inline ::Version* Package::release_version() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::Version* Package::unsafe_arena_release_version() {
-  // @@protoc_insertion_point(field_release:Package.version)
+inline ::rsh::protocol::Version* Package::unsafe_arena_release_version() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.Package.version)
   
-  ::Version* temp = _impl_.version_;
+  ::rsh::protocol::Version* temp = _impl_.version_;
   _impl_.version_ = nullptr;
   return temp;
 }
-inline ::Version* Package::_internal_mutable_version() {
+inline ::rsh::protocol::Version* Package::_internal_mutable_version() {
   
   if (_impl_.version_ == nullptr) {
-    auto* p = CreateMaybeMessage<::Version>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::Version>(GetArenaForAllocation());
     _impl_.version_ = p;
   }
   return _impl_.version_;
 }
-inline ::Version* Package::mutable_version() {
-  ::Version* _msg = _internal_mutable_version();
-  // @@protoc_insertion_point(field_mutable:Package.version)
+inline ::rsh::protocol::Version* Package::mutable_version() {
+  ::rsh::protocol::Version* _msg = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Package.version)
   return _msg;
 }
-inline void Package::set_allocated_version(::Version* version) {
+inline void Package::set_allocated_version(::rsh::protocol::Version* version) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.version_;
@@ -7414,7 +7420,7 @@ inline void Package::set_allocated_version(::Version* version) {
     
   }
   _impl_.version_ = version;
-  // @@protoc_insertion_point(field_set_allocated:Package.version)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Package.version)
 }
 
 // repeated bytes function_hashes = 4;
@@ -7429,70 +7435,70 @@ inline void Package::clear_function_hashes() {
 }
 inline std::string* Package::add_function_hashes() {
   std::string* _s = _internal_add_function_hashes();
-  // @@protoc_insertion_point(field_add_mutable:Package.function_hashes)
+  // @@protoc_insertion_point(field_add_mutable:rsh.protocol.Package.function_hashes)
   return _s;
 }
 inline const std::string& Package::_internal_function_hashes(int index) const {
   return _impl_.function_hashes_.Get(index);
 }
 inline const std::string& Package::function_hashes(int index) const {
-  // @@protoc_insertion_point(field_get:Package.function_hashes)
+  // @@protoc_insertion_point(field_get:rsh.protocol.Package.function_hashes)
   return _internal_function_hashes(index);
 }
 inline std::string* Package::mutable_function_hashes(int index) {
-  // @@protoc_insertion_point(field_mutable:Package.function_hashes)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Package.function_hashes)
   return _impl_.function_hashes_.Mutable(index);
 }
 inline void Package::set_function_hashes(int index, const std::string& value) {
   _impl_.function_hashes_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:Package.function_hashes)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Package.function_hashes)
 }
 inline void Package::set_function_hashes(int index, std::string&& value) {
   _impl_.function_hashes_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:Package.function_hashes)
+  // @@protoc_insertion_point(field_set:rsh.protocol.Package.function_hashes)
 }
 inline void Package::set_function_hashes(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   _impl_.function_hashes_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:Package.function_hashes)
+  // @@protoc_insertion_point(field_set_char:rsh.protocol.Package.function_hashes)
 }
 inline void Package::set_function_hashes(int index, const void* value, size_t size) {
   _impl_.function_hashes_.Mutable(index)->assign(
     reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:Package.function_hashes)
+  // @@protoc_insertion_point(field_set_pointer:rsh.protocol.Package.function_hashes)
 }
 inline std::string* Package::_internal_add_function_hashes() {
   return _impl_.function_hashes_.Add();
 }
 inline void Package::add_function_hashes(const std::string& value) {
   _impl_.function_hashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:Package.function_hashes)
+  // @@protoc_insertion_point(field_add:rsh.protocol.Package.function_hashes)
 }
 inline void Package::add_function_hashes(std::string&& value) {
   _impl_.function_hashes_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:Package.function_hashes)
+  // @@protoc_insertion_point(field_add:rsh.protocol.Package.function_hashes)
 }
 inline void Package::add_function_hashes(const char* value) {
   GOOGLE_DCHECK(value != nullptr);
   _impl_.function_hashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:Package.function_hashes)
+  // @@protoc_insertion_point(field_add_char:rsh.protocol.Package.function_hashes)
 }
 inline void Package::add_function_hashes(const void* value, size_t size) {
   _impl_.function_hashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:Package.function_hashes)
+  // @@protoc_insertion_point(field_add_pointer:rsh.protocol.Package.function_hashes)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
 Package::function_hashes() const {
-  // @@protoc_insertion_point(field_list:Package.function_hashes)
+  // @@protoc_insertion_point(field_list:rsh.protocol.Package.function_hashes)
   return _impl_.function_hashes_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
 Package::mutable_function_hashes() {
-  // @@protoc_insertion_point(field_mutable_list:Package.function_hashes)
+  // @@protoc_insertion_point(field_mutable_list:rsh.protocol.Package.function_hashes)
   return &_impl_.function_hashes_;
 }
 
-// optional .PackageSource source = 5;
+// optional .rsh.protocol.PackageSource source = 5;
 inline bool Package::_internal_has_source() const {
   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
   PROTOBUF_ASSUME(!value || _impl_.source_ != nullptr);
@@ -7505,17 +7511,17 @@ inline void Package::clear_source() {
   if (_impl_.source_ != nullptr) _impl_.source_->Clear();
   _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline const ::PackageSource& Package::_internal_source() const {
-  const ::PackageSource* p = _impl_.source_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PackageSource&>(
-      ::_PackageSource_default_instance_);
+inline const ::rsh::protocol::PackageSource& Package::_internal_source() const {
+  const ::rsh::protocol::PackageSource* p = _impl_.source_;
+  return p != nullptr ? *p : reinterpret_cast<const ::rsh::protocol::PackageSource&>(
+      ::rsh::protocol::_PackageSource_default_instance_);
 }
-inline const ::PackageSource& Package::source() const {
-  // @@protoc_insertion_point(field_get:Package.source)
+inline const ::rsh::protocol::PackageSource& Package::source() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.Package.source)
   return _internal_source();
 }
 inline void Package::unsafe_arena_set_allocated_source(
-    ::PackageSource* source) {
+    ::rsh::protocol::PackageSource* source) {
   if (GetArenaForAllocation() == nullptr) {
     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_);
   }
@@ -7525,11 +7531,11 @@ inline void Package::unsafe_arena_set_allocated_source(
   } else {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Package.source)
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.protocol.Package.source)
 }
-inline ::PackageSource* Package::release_source() {
+inline ::rsh::protocol::PackageSource* Package::release_source() {
   _impl_._has_bits_[0] &= ~0x00000001u;
-  ::PackageSource* temp = _impl_.source_;
+  ::rsh::protocol::PackageSource* temp = _impl_.source_;
   _impl_.source_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
@@ -7542,27 +7548,27 @@ inline ::PackageSource* Package::release_source() {
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::PackageSource* Package::unsafe_arena_release_source() {
-  // @@protoc_insertion_point(field_release:Package.source)
+inline ::rsh::protocol::PackageSource* Package::unsafe_arena_release_source() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.Package.source)
   _impl_._has_bits_[0] &= ~0x00000001u;
-  ::PackageSource* temp = _impl_.source_;
+  ::rsh::protocol::PackageSource* temp = _impl_.source_;
   _impl_.source_ = nullptr;
   return temp;
 }
-inline ::PackageSource* Package::_internal_mutable_source() {
+inline ::rsh::protocol::PackageSource* Package::_internal_mutable_source() {
   _impl_._has_bits_[0] |= 0x00000001u;
   if (_impl_.source_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PackageSource>(GetArenaForAllocation());
+    auto* p = CreateMaybeMessage<::rsh::protocol::PackageSource>(GetArenaForAllocation());
     _impl_.source_ = p;
   }
   return _impl_.source_;
 }
-inline ::PackageSource* Package::mutable_source() {
-  ::PackageSource* _msg = _internal_mutable_source();
-  // @@protoc_insertion_point(field_mutable:Package.source)
+inline ::rsh::protocol::PackageSource* Package::mutable_source() {
+  ::rsh::protocol::PackageSource* _msg = _internal_mutable_source();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.Package.source)
   return _msg;
 }
-inline void Package::set_allocated_source(::PackageSource* source) {
+inline void Package::set_allocated_source(::rsh::protocol::PackageSource* source) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
     delete _impl_.source_;
@@ -7579,7 +7585,7 @@ inline void Package::set_allocated_source(::PackageSource* source) {
     _impl_._has_bits_[0] &= ~0x00000001u;
   }
   _impl_.source_ = source;
-  // @@protoc_insertion_point(field_set_allocated:Package.source)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Package.source)
 }
 
 // -------------------------------------------------------------------
@@ -7591,7 +7597,7 @@ inline void PackageRequest::clear_hash() {
   _impl_.hash_.ClearToEmpty();
 }
 inline const std::string& PackageRequest::hash() const {
-  // @@protoc_insertion_point(field_get:PackageRequest.hash)
+  // @@protoc_insertion_point(field_get:rsh.protocol.PackageRequest.hash)
   return _internal_hash();
 }
 template <typename ArgT0, typename... ArgT>
@@ -7599,11 +7605,11 @@ inline PROTOBUF_ALWAYS_INLINE
 void PackageRequest::set_hash(ArgT0&& arg0, ArgT... args) {
  
  _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:PackageRequest.hash)
+  // @@protoc_insertion_point(field_set:rsh.protocol.PackageRequest.hash)
 }
 inline std::string* PackageRequest::mutable_hash() {
   std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:PackageRequest.hash)
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.PackageRequest.hash)
   return _s;
 }
 inline const std::string& PackageRequest::_internal_hash() const {
@@ -7618,7 +7624,7 @@ inline std::string* PackageRequest::_internal_mutable_hash() {
   return _impl_.hash_.Mutable(GetArenaForAllocation());
 }
 inline std::string* PackageRequest::release_hash() {
-  // @@protoc_insertion_point(field_release:PackageRequest.hash)
+  // @@protoc_insertion_point(field_release:rsh.protocol.PackageRequest.hash)
   return _impl_.hash_.Release();
 }
 inline void PackageRequest::set_allocated_hash(std::string* hash) {
@@ -7633,7 +7639,7 @@ inline void PackageRequest::set_allocated_hash(std::string* hash) {
     _impl_.hash_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:PackageRequest.hash)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.PackageRequest.hash)
 }
 
 #ifdef __GNUC__
@@ -7694,23 +7700,25 @@ inline void PackageRequest::set_allocated_hash(std::string* hash) {
 
 // @@protoc_insertion_point(namespace_scope)
 
+}  // namespace protocol
+}  // namespace rsh
 
 PROTOBUF_NAMESPACE_OPEN
 
-template <> struct is_proto_enum< ::Tier> : ::std::true_type {};
+template <> struct is_proto_enum< ::rsh::protocol::Tier> : ::std::true_type {};
 template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::Tier>() {
-  return ::Tier_descriptor();
+inline const EnumDescriptor* GetEnumDescriptor< ::rsh::protocol::Tier>() {
+  return ::rsh::protocol::Tier_descriptor();
 }
-template <> struct is_proto_enum< ::TestLattice> : ::std::true_type {};
+template <> struct is_proto_enum< ::rsh::protocol::TestLattice> : ::std::true_type {};
 template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::TestLattice>() {
-  return ::TestLattice_descriptor();
+inline const EnumDescriptor* GetEnumDescriptor< ::rsh::protocol::TestLattice>() {
+  return ::rsh::protocol::TestLattice_descriptor();
 }
-template <> struct is_proto_enum< ::Type> : ::std::true_type {};
+template <> struct is_proto_enum< ::rsh::protocol::Type> : ::std::true_type {};
 template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::Type>() {
-  return ::Type_descriptor();
+inline const EnumDescriptor* GetEnumDescriptor< ::rsh::protocol::Type>() {
+  return ::rsh::protocol::Type_descriptor();
 }
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/client/rsh/src/routes.grpc.pb.cc b/client/rsh/src/routes.grpc.pb.cc
new file mode 100644
index 000000000..4401319b1
--- /dev/null
+++ b/client/rsh/src/routes.grpc.pb.cc
@@ -0,0 +1,317 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: routes.proto
+
+#include "routes.pb.h"
+#include "routes.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/support/async_stream.h>
+#include <grpcpp/support/async_unary_call.h>
+#include <grpcpp/impl/channel_interface.h>
+#include <grpcpp/impl/client_unary_call.h>
+#include <grpcpp/support/client_callback.h>
+#include <grpcpp/support/message_allocator.h>
+#include <grpcpp/support/method_handler.h>
+#include <grpcpp/impl/rpc_service_method.h>
+#include <grpcpp/support/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/server_context.h>
+#include <grpcpp/impl/service_type.h>
+#include <grpcpp/support/sync_stream.h>
+namespace rsh {
+namespace protocol {
+
+static const char* CompileService_method_names[] = {
+  "/rsh.protocol.CompileService/Compile",
+  "/rsh.protocol.CompileService/Init",
+};
+
+std::unique_ptr< CompileService::Stub> CompileService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< CompileService::Stub> stub(new CompileService::Stub(channel, options));
+  return stub;
+}
+
+CompileService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
+  : channel_(channel), rpcmethod_Compile_(CompileService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_Init_(CompileService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status CompileService::Stub::Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::rsh::protocol::CompileResponse* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Compile_, context, request, response);
+}
+
+void CompileService::Stub::async::Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Compile_, context, request, response, std::move(f));
+}
+
+void CompileService::Stub::async::Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Compile_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>* CompileService::Stub::PrepareAsyncCompileRaw(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::rsh::protocol::CompileResponse, ::rsh::protocol::CompileRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Compile_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>* CompileService::Stub::AsyncCompileRaw(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncCompileRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status CompileService::Stub::Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::rsh::protocol::InitResponse* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Init_, context, request, response);
+}
+
+void CompileService::Stub::async::Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Init_, context, request, response, std::move(f));
+}
+
+void CompileService::Stub::async::Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Init_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>* CompileService::Stub::PrepareAsyncInitRaw(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::rsh::protocol::InitResponse, ::rsh::protocol::InitRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Init_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>* CompileService::Stub::AsyncInitRaw(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncInitRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+CompileService::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      CompileService_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< CompileService::Service, ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](CompileService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::rsh::protocol::CompileRequest* req,
+             ::rsh::protocol::CompileResponse* resp) {
+               return service->Compile(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      CompileService_method_names[1],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< CompileService::Service, ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](CompileService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::rsh::protocol::InitRequest* req,
+             ::rsh::protocol::InitResponse* resp) {
+               return service->Init(ctx, req, resp);
+             }, this)));
+}
+
+CompileService::Service::~Service() {
+}
+
+::grpc::Status CompileService::Service::Compile(::grpc::ServerContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status CompileService::Service::Init(::grpc::ServerContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+static const char* FactService_method_names[] = {
+  "/rsh.protocol.FactService/GetContext",
+  "/rsh.protocol.FactService/GetTypeFeedback",
+  "/rsh.protocol.FactService/GetValues",
+  "/rsh.protocol.FactService/GetFunction",
+};
+
+std::unique_ptr< FactService::Stub> FactService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< FactService::Stub> stub(new FactService::Stub(channel, options));
+  return stub;
+}
+
+FactService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
+  : channel_(channel), rpcmethod_GetContext_(FactService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_GetTypeFeedback_(FactService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_GetValues_(FactService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_GetFunction_(FactService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status FactService::Stub::GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::rsh::protocol::Context* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::rsh::protocol::ContextRequest, ::rsh::protocol::Context, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetContext_, context, request, response);
+}
+
+void FactService::Stub::async::GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::rsh::protocol::ContextRequest, ::rsh::protocol::Context, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetContext_, context, request, response, std::move(f));
+}
+
+void FactService::Stub::async::GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetContext_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>* FactService::Stub::PrepareAsyncGetContextRaw(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::rsh::protocol::Context, ::rsh::protocol::ContextRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetContext_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>* FactService::Stub::AsyncGetContextRaw(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncGetContextRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status FactService::Stub::GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::rsh::protocol::TypeFeedback* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetTypeFeedback_, context, request, response);
+}
+
+void FactService::Stub::async::GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTypeFeedback_, context, request, response, std::move(f));
+}
+
+void FactService::Stub::async::GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTypeFeedback_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>* FactService::Stub::PrepareAsyncGetTypeFeedbackRaw(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::rsh::protocol::TypeFeedback, ::rsh::protocol::FeedbackRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetTypeFeedback_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>* FactService::Stub::AsyncGetTypeFeedbackRaw(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncGetTypeFeedbackRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status FactService::Stub::GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::rsh::protocol::Values* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::rsh::protocol::ValueRequest, ::rsh::protocol::Values, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetValues_, context, request, response);
+}
+
+void FactService::Stub::async::GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::rsh::protocol::ValueRequest, ::rsh::protocol::Values, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetValues_, context, request, response, std::move(f));
+}
+
+void FactService::Stub::async::GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetValues_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>* FactService::Stub::PrepareAsyncGetValuesRaw(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::rsh::protocol::Values, ::rsh::protocol::ValueRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetValues_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>* FactService::Stub::AsyncGetValuesRaw(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncGetValuesRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status FactService::Stub::GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::rsh::protocol::Function* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetFunction_, context, request, response);
+}
+
+void FactService::Stub::async::GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetFunction_, context, request, response, std::move(f));
+}
+
+void FactService::Stub::async::GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetFunction_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>* FactService::Stub::PrepareAsyncGetFunctionRaw(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::rsh::protocol::Function, ::rsh::protocol::FunctionRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetFunction_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>* FactService::Stub::AsyncGetFunctionRaw(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncGetFunctionRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+FactService::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      FactService_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< FactService::Service, ::rsh::protocol::ContextRequest, ::rsh::protocol::Context, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](FactService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::rsh::protocol::ContextRequest* req,
+             ::rsh::protocol::Context* resp) {
+               return service->GetContext(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      FactService_method_names[1],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< FactService::Service, ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](FactService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::rsh::protocol::FeedbackRequest* req,
+             ::rsh::protocol::TypeFeedback* resp) {
+               return service->GetTypeFeedback(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      FactService_method_names[2],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< FactService::Service, ::rsh::protocol::ValueRequest, ::rsh::protocol::Values, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](FactService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::rsh::protocol::ValueRequest* req,
+             ::rsh::protocol::Values* resp) {
+               return service->GetValues(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      FactService_method_names[3],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< FactService::Service, ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](FactService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::rsh::protocol::FunctionRequest* req,
+             ::rsh::protocol::Function* resp) {
+               return service->GetFunction(ctx, req, resp);
+             }, this)));
+}
+
+FactService::Service::~Service() {
+}
+
+::grpc::Status FactService::Service::GetContext(::grpc::ServerContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status FactService::Service::GetTypeFeedback(::grpc::ServerContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status FactService::Service::GetValues(::grpc::ServerContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status FactService::Service::GetFunction(::grpc::ServerContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace rsh
+}  // namespace protocol
+
diff --git a/client/rsh/src/routes.grpc.pb.h b/client/rsh/src/routes.grpc.pb.h
new file mode 100644
index 000000000..38f98ea0a
--- /dev/null
+++ b/client/rsh/src/routes.grpc.pb.h
@@ -0,0 +1,1080 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: routes.proto
+#ifndef GRPC_routes_2eproto__INCLUDED
+#define GRPC_routes_2eproto__INCLUDED
+
+#include "routes.pb.h"
+
+#include <functional>
+#include <grpcpp/generic/async_generic_service.h>
+#include <grpcpp/support/async_stream.h>
+#include <grpcpp/support/async_unary_call.h>
+#include <grpcpp/support/client_callback.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/completion_queue.h>
+#include <grpcpp/support/message_allocator.h>
+#include <grpcpp/support/method_handler.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/rpc_method.h>
+#include <grpcpp/support/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/server_context.h>
+#include <grpcpp/impl/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/support/stub_options.h>
+#include <grpcpp/support/sync_stream.h>
+
+namespace rsh {
+namespace protocol {
+
+// R sends requests to the compile server
+class CompileService final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "rsh.protocol.CompileService";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    virtual ::grpc::Status Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::rsh::protocol::CompileResponse* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::CompileResponse>> AsyncCompile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::CompileResponse>>(AsyncCompileRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::CompileResponse>> PrepareAsyncCompile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::CompileResponse>>(PrepareAsyncCompileRaw(context, request, cq));
+    }
+    virtual ::grpc::Status Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::rsh::protocol::InitResponse* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::InitResponse>> AsyncInit(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::InitResponse>>(AsyncInitRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::InitResponse>> PrepareAsyncInit(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::InitResponse>>(PrepareAsyncInitRaw(context, request, cq));
+    }
+    class async_interface {
+     public:
+      virtual ~async_interface() {}
+      virtual void Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      virtual void Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+    };
+    typedef class async_interface experimental_async_interface;
+    virtual class async_interface* async() { return nullptr; }
+    class async_interface* experimental_async() { return async(); }
+   private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::CompileResponse>* AsyncCompileRaw(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::CompileResponse>* PrepareAsyncCompileRaw(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::InitResponse>* AsyncInitRaw(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::InitResponse>* PrepareAsyncInitRaw(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+    ::grpc::Status Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::rsh::protocol::CompileResponse* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>> AsyncCompile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>>(AsyncCompileRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>> PrepareAsyncCompile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>>(PrepareAsyncCompileRaw(context, request, cq));
+    }
+    ::grpc::Status Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::rsh::protocol::InitResponse* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>> AsyncInit(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>>(AsyncInitRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>> PrepareAsyncInit(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>>(PrepareAsyncInitRaw(context, request, cq));
+    }
+    class async final :
+      public StubInterface::async_interface {
+     public:
+      void Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response, std::function<void(::grpc::Status)>) override;
+      void Compile(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
+      void Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response, std::function<void(::grpc::Status)>) override;
+      void Init(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
+     private:
+      friend class Stub;
+      explicit async(Stub* stub): stub_(stub) { }
+      Stub* stub() { return stub_; }
+      Stub* stub_;
+    };
+    class async* async() override { return &async_stub_; }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    class async async_stub_{this};
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>* AsyncCompileRaw(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::CompileResponse>* PrepareAsyncCompileRaw(::grpc::ClientContext* context, const ::rsh::protocol::CompileRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>* AsyncInitRaw(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::InitResponse>* PrepareAsyncInitRaw(::grpc::ClientContext* context, const ::rsh::protocol::InitRequest& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_Compile_;
+    const ::grpc::internal::RpcMethod rpcmethod_Init_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    virtual ::grpc::Status Compile(::grpc::ServerContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response);
+    virtual ::grpc::Status Init(::grpc::ServerContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_Compile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_Compile() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_Compile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Compile(::grpc::ServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCompile(::grpc::ServerContext* context, ::rsh::protocol::CompileRequest* request, ::grpc::ServerAsyncResponseWriter< ::rsh::protocol::CompileResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_Init : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_Init() {
+      ::grpc::Service::MarkMethodAsync(1);
+    }
+    ~WithAsyncMethod_Init() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Init(::grpc::ServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestInit(::grpc::ServerContext* context, ::rsh::protocol::InitRequest* request, ::grpc::ServerAsyncResponseWriter< ::rsh::protocol::InitResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_Compile<WithAsyncMethod_Init<Service > > AsyncService;
+  template <class BaseClass>
+  class WithCallbackMethod_Compile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_Compile() {
+      ::grpc::Service::MarkMethodCallback(0,
+          new ::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::rsh::protocol::CompileRequest* request, ::rsh::protocol::CompileResponse* response) { return this->Compile(context, request, response); }));}
+    void SetMessageAllocatorFor_Compile(
+        ::grpc::MessageAllocator< ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse>* allocator) {
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~WithCallbackMethod_Compile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Compile(::grpc::ServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* Compile(
+      ::grpc::CallbackServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithCallbackMethod_Init : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_Init() {
+      ::grpc::Service::MarkMethodCallback(1,
+          new ::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::rsh::protocol::InitRequest* request, ::rsh::protocol::InitResponse* response) { return this->Init(context, request, response); }));}
+    void SetMessageAllocatorFor_Init(
+        ::grpc::MessageAllocator< ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse>* allocator) {
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~WithCallbackMethod_Init() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Init(::grpc::ServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* Init(
+      ::grpc::CallbackServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/)  { return nullptr; }
+  };
+  typedef WithCallbackMethod_Compile<WithCallbackMethod_Init<Service > > CallbackService;
+  typedef CallbackService ExperimentalCallbackService;
+  template <class BaseClass>
+  class WithGenericMethod_Compile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_Compile() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_Compile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Compile(::grpc::ServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_Init : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_Init() {
+      ::grpc::Service::MarkMethodGeneric(1);
+    }
+    ~WithGenericMethod_Init() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Init(::grpc::ServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_Compile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_Compile() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_Compile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Compile(::grpc::ServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCompile(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_Init : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_Init() {
+      ::grpc::Service::MarkMethodRaw(1);
+    }
+    ~WithRawMethod_Init() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Init(::grpc::ServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestInit(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawCallbackMethod_Compile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_Compile() {
+      ::grpc::Service::MarkMethodRawCallback(0,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Compile(context, request, response); }));
+    }
+    ~WithRawCallbackMethod_Compile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Compile(::grpc::ServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* Compile(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithRawCallbackMethod_Init : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_Init() {
+      ::grpc::Service::MarkMethodRawCallback(1,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Init(context, request, response); }));
+    }
+    ~WithRawCallbackMethod_Init() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Init(::grpc::ServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* Init(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_Compile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_Compile() {
+      ::grpc::Service::MarkMethodStreamed(0,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::rsh::protocol::CompileRequest, ::rsh::protocol::CompileResponse>* streamer) {
+                       return this->StreamedCompile(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_Compile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status Compile(::grpc::ServerContext* /*context*/, const ::rsh::protocol::CompileRequest* /*request*/, ::rsh::protocol::CompileResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedCompile(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::rsh::protocol::CompileRequest,::rsh::protocol::CompileResponse>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_Init : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_Init() {
+      ::grpc::Service::MarkMethodStreamed(1,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::rsh::protocol::InitRequest, ::rsh::protocol::InitResponse>* streamer) {
+                       return this->StreamedInit(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_Init() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status Init(::grpc::ServerContext* /*context*/, const ::rsh::protocol::InitRequest* /*request*/, ::rsh::protocol::InitResponse* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedInit(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::rsh::protocol::InitRequest,::rsh::protocol::InitResponse>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_Compile<WithStreamedUnaryMethod_Init<Service > > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_Compile<WithStreamedUnaryMethod_Init<Service > > StreamedService;
+};
+
+// Used by the compile server to ask questions to R
+// The server part there should be in the C++ code
+class FactService final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "rsh.protocol.FactService";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    virtual ::grpc::Status GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::rsh::protocol::Context* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Context>> AsyncGetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Context>>(AsyncGetContextRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Context>> PrepareAsyncGetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Context>>(PrepareAsyncGetContextRaw(context, request, cq));
+    }
+    virtual ::grpc::Status GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::rsh::protocol::TypeFeedback* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::TypeFeedback>> AsyncGetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::TypeFeedback>>(AsyncGetTypeFeedbackRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::TypeFeedback>> PrepareAsyncGetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::TypeFeedback>>(PrepareAsyncGetTypeFeedbackRaw(context, request, cq));
+    }
+    virtual ::grpc::Status GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::rsh::protocol::Values* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Values>> AsyncGetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Values>>(AsyncGetValuesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Values>> PrepareAsyncGetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Values>>(PrepareAsyncGetValuesRaw(context, request, cq));
+    }
+    virtual ::grpc::Status GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::rsh::protocol::Function* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Function>> AsyncGetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Function>>(AsyncGetFunctionRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Function>> PrepareAsyncGetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Function>>(PrepareAsyncGetFunctionRaw(context, request, cq));
+    }
+    class async_interface {
+     public:
+      virtual ~async_interface() {}
+      virtual void GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      virtual void GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      virtual void GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      virtual void GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+    };
+    typedef class async_interface experimental_async_interface;
+    virtual class async_interface* async() { return nullptr; }
+    class async_interface* experimental_async() { return async(); }
+   private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Context>* AsyncGetContextRaw(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Context>* PrepareAsyncGetContextRaw(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::TypeFeedback>* AsyncGetTypeFeedbackRaw(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::TypeFeedback>* PrepareAsyncGetTypeFeedbackRaw(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Values>* AsyncGetValuesRaw(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Values>* PrepareAsyncGetValuesRaw(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Function>* AsyncGetFunctionRaw(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::rsh::protocol::Function>* PrepareAsyncGetFunctionRaw(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+    ::grpc::Status GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::rsh::protocol::Context* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>> AsyncGetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>>(AsyncGetContextRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>> PrepareAsyncGetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>>(PrepareAsyncGetContextRaw(context, request, cq));
+    }
+    ::grpc::Status GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::rsh::protocol::TypeFeedback* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>> AsyncGetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>>(AsyncGetTypeFeedbackRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>> PrepareAsyncGetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>>(PrepareAsyncGetTypeFeedbackRaw(context, request, cq));
+    }
+    ::grpc::Status GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::rsh::protocol::Values* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>> AsyncGetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>>(AsyncGetValuesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>> PrepareAsyncGetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>>(PrepareAsyncGetValuesRaw(context, request, cq));
+    }
+    ::grpc::Status GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::rsh::protocol::Function* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>> AsyncGetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>>(AsyncGetFunctionRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>> PrepareAsyncGetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>>(PrepareAsyncGetFunctionRaw(context, request, cq));
+    }
+    class async final :
+      public StubInterface::async_interface {
+     public:
+      void GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response, std::function<void(::grpc::Status)>) override;
+      void GetContext(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response, ::grpc::ClientUnaryReactor* reactor) override;
+      void GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response, std::function<void(::grpc::Status)>) override;
+      void GetTypeFeedback(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response, ::grpc::ClientUnaryReactor* reactor) override;
+      void GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response, std::function<void(::grpc::Status)>) override;
+      void GetValues(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response, ::grpc::ClientUnaryReactor* reactor) override;
+      void GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response, std::function<void(::grpc::Status)>) override;
+      void GetFunction(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response, ::grpc::ClientUnaryReactor* reactor) override;
+     private:
+      friend class Stub;
+      explicit async(Stub* stub): stub_(stub) { }
+      Stub* stub() { return stub_; }
+      Stub* stub_;
+    };
+    class async* async() override { return &async_stub_; }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    class async async_stub_{this};
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>* AsyncGetContextRaw(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Context>* PrepareAsyncGetContextRaw(::grpc::ClientContext* context, const ::rsh::protocol::ContextRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>* AsyncGetTypeFeedbackRaw(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::TypeFeedback>* PrepareAsyncGetTypeFeedbackRaw(::grpc::ClientContext* context, const ::rsh::protocol::FeedbackRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>* AsyncGetValuesRaw(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Values>* PrepareAsyncGetValuesRaw(::grpc::ClientContext* context, const ::rsh::protocol::ValueRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>* AsyncGetFunctionRaw(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::rsh::protocol::Function>* PrepareAsyncGetFunctionRaw(::grpc::ClientContext* context, const ::rsh::protocol::FunctionRequest& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_GetContext_;
+    const ::grpc::internal::RpcMethod rpcmethod_GetTypeFeedback_;
+    const ::grpc::internal::RpcMethod rpcmethod_GetValues_;
+    const ::grpc::internal::RpcMethod rpcmethod_GetFunction_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    virtual ::grpc::Status GetContext(::grpc::ServerContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response);
+    virtual ::grpc::Status GetTypeFeedback(::grpc::ServerContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response);
+    virtual ::grpc::Status GetValues(::grpc::ServerContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response);
+    virtual ::grpc::Status GetFunction(::grpc::ServerContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_GetContext : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_GetContext() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_GetContext() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetContext(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetContext(::grpc::ServerContext* context, ::rsh::protocol::ContextRequest* request, ::grpc::ServerAsyncResponseWriter< ::rsh::protocol::Context>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_GetTypeFeedback : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_GetTypeFeedback() {
+      ::grpc::Service::MarkMethodAsync(1);
+    }
+    ~WithAsyncMethod_GetTypeFeedback() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetTypeFeedback(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetTypeFeedback(::grpc::ServerContext* context, ::rsh::protocol::FeedbackRequest* request, ::grpc::ServerAsyncResponseWriter< ::rsh::protocol::TypeFeedback>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_GetValues : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_GetValues() {
+      ::grpc::Service::MarkMethodAsync(2);
+    }
+    ~WithAsyncMethod_GetValues() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetValues(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetValues(::grpc::ServerContext* context, ::rsh::protocol::ValueRequest* request, ::grpc::ServerAsyncResponseWriter< ::rsh::protocol::Values>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_GetFunction : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_GetFunction() {
+      ::grpc::Service::MarkMethodAsync(3);
+    }
+    ~WithAsyncMethod_GetFunction() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetFunction(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetFunction(::grpc::ServerContext* context, ::rsh::protocol::FunctionRequest* request, ::grpc::ServerAsyncResponseWriter< ::rsh::protocol::Function>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_GetContext<WithAsyncMethod_GetTypeFeedback<WithAsyncMethod_GetValues<WithAsyncMethod_GetFunction<Service > > > > AsyncService;
+  template <class BaseClass>
+  class WithCallbackMethod_GetContext : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_GetContext() {
+      ::grpc::Service::MarkMethodCallback(0,
+          new ::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::ContextRequest, ::rsh::protocol::Context>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::rsh::protocol::ContextRequest* request, ::rsh::protocol::Context* response) { return this->GetContext(context, request, response); }));}
+    void SetMessageAllocatorFor_GetContext(
+        ::grpc::MessageAllocator< ::rsh::protocol::ContextRequest, ::rsh::protocol::Context>* allocator) {
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::ContextRequest, ::rsh::protocol::Context>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~WithCallbackMethod_GetContext() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetContext(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetContext(
+      ::grpc::CallbackServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithCallbackMethod_GetTypeFeedback : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_GetTypeFeedback() {
+      ::grpc::Service::MarkMethodCallback(1,
+          new ::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::rsh::protocol::FeedbackRequest* request, ::rsh::protocol::TypeFeedback* response) { return this->GetTypeFeedback(context, request, response); }));}
+    void SetMessageAllocatorFor_GetTypeFeedback(
+        ::grpc::MessageAllocator< ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback>* allocator) {
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~WithCallbackMethod_GetTypeFeedback() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetTypeFeedback(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetTypeFeedback(
+      ::grpc::CallbackServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithCallbackMethod_GetValues : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_GetValues() {
+      ::grpc::Service::MarkMethodCallback(2,
+          new ::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::ValueRequest, ::rsh::protocol::Values>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::rsh::protocol::ValueRequest* request, ::rsh::protocol::Values* response) { return this->GetValues(context, request, response); }));}
+    void SetMessageAllocatorFor_GetValues(
+        ::grpc::MessageAllocator< ::rsh::protocol::ValueRequest, ::rsh::protocol::Values>* allocator) {
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::ValueRequest, ::rsh::protocol::Values>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~WithCallbackMethod_GetValues() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetValues(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetValues(
+      ::grpc::CallbackServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithCallbackMethod_GetFunction : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithCallbackMethod_GetFunction() {
+      ::grpc::Service::MarkMethodCallback(3,
+          new ::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::rsh::protocol::FunctionRequest* request, ::rsh::protocol::Function* response) { return this->GetFunction(context, request, response); }));}
+    void SetMessageAllocatorFor_GetFunction(
+        ::grpc::MessageAllocator< ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function>* allocator) {
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3);
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~WithCallbackMethod_GetFunction() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetFunction(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetFunction(
+      ::grpc::CallbackServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/)  { return nullptr; }
+  };
+  typedef WithCallbackMethod_GetContext<WithCallbackMethod_GetTypeFeedback<WithCallbackMethod_GetValues<WithCallbackMethod_GetFunction<Service > > > > CallbackService;
+  typedef CallbackService ExperimentalCallbackService;
+  template <class BaseClass>
+  class WithGenericMethod_GetContext : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_GetContext() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_GetContext() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetContext(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_GetTypeFeedback : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_GetTypeFeedback() {
+      ::grpc::Service::MarkMethodGeneric(1);
+    }
+    ~WithGenericMethod_GetTypeFeedback() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetTypeFeedback(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_GetValues : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_GetValues() {
+      ::grpc::Service::MarkMethodGeneric(2);
+    }
+    ~WithGenericMethod_GetValues() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetValues(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_GetFunction : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_GetFunction() {
+      ::grpc::Service::MarkMethodGeneric(3);
+    }
+    ~WithGenericMethod_GetFunction() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetFunction(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_GetContext : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_GetContext() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_GetContext() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetContext(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetContext(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_GetTypeFeedback : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_GetTypeFeedback() {
+      ::grpc::Service::MarkMethodRaw(1);
+    }
+    ~WithRawMethod_GetTypeFeedback() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetTypeFeedback(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetTypeFeedback(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_GetValues : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_GetValues() {
+      ::grpc::Service::MarkMethodRaw(2);
+    }
+    ~WithRawMethod_GetValues() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetValues(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetValues(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_GetFunction : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_GetFunction() {
+      ::grpc::Service::MarkMethodRaw(3);
+    }
+    ~WithRawMethod_GetFunction() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetFunction(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestGetFunction(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawCallbackMethod_GetContext : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_GetContext() {
+      ::grpc::Service::MarkMethodRawCallback(0,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetContext(context, request, response); }));
+    }
+    ~WithRawCallbackMethod_GetContext() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetContext(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetContext(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithRawCallbackMethod_GetTypeFeedback : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_GetTypeFeedback() {
+      ::grpc::Service::MarkMethodRawCallback(1,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetTypeFeedback(context, request, response); }));
+    }
+    ~WithRawCallbackMethod_GetTypeFeedback() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetTypeFeedback(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetTypeFeedback(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithRawCallbackMethod_GetValues : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_GetValues() {
+      ::grpc::Service::MarkMethodRawCallback(2,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetValues(context, request, response); }));
+    }
+    ~WithRawCallbackMethod_GetValues() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetValues(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetValues(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithRawCallbackMethod_GetFunction : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawCallbackMethod_GetFunction() {
+      ::grpc::Service::MarkMethodRawCallback(3,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetFunction(context, request, response); }));
+    }
+    ~WithRawCallbackMethod_GetFunction() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status GetFunction(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual ::grpc::ServerUnaryReactor* GetFunction(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_GetContext : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_GetContext() {
+      ::grpc::Service::MarkMethodStreamed(0,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::rsh::protocol::ContextRequest, ::rsh::protocol::Context>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::rsh::protocol::ContextRequest, ::rsh::protocol::Context>* streamer) {
+                       return this->StreamedGetContext(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_GetContext() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status GetContext(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ContextRequest* /*request*/, ::rsh::protocol::Context* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedGetContext(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::rsh::protocol::ContextRequest,::rsh::protocol::Context>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_GetTypeFeedback : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_GetTypeFeedback() {
+      ::grpc::Service::MarkMethodStreamed(1,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::rsh::protocol::FeedbackRequest, ::rsh::protocol::TypeFeedback>* streamer) {
+                       return this->StreamedGetTypeFeedback(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_GetTypeFeedback() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status GetTypeFeedback(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FeedbackRequest* /*request*/, ::rsh::protocol::TypeFeedback* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedGetTypeFeedback(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::rsh::protocol::FeedbackRequest,::rsh::protocol::TypeFeedback>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_GetValues : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_GetValues() {
+      ::grpc::Service::MarkMethodStreamed(2,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::rsh::protocol::ValueRequest, ::rsh::protocol::Values>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::rsh::protocol::ValueRequest, ::rsh::protocol::Values>* streamer) {
+                       return this->StreamedGetValues(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_GetValues() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status GetValues(::grpc::ServerContext* /*context*/, const ::rsh::protocol::ValueRequest* /*request*/, ::rsh::protocol::Values* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedGetValues(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::rsh::protocol::ValueRequest,::rsh::protocol::Values>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_GetFunction : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_GetFunction() {
+      ::grpc::Service::MarkMethodStreamed(3,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::rsh::protocol::FunctionRequest, ::rsh::protocol::Function>* streamer) {
+                       return this->StreamedGetFunction(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_GetFunction() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status GetFunction(::grpc::ServerContext* /*context*/, const ::rsh::protocol::FunctionRequest* /*request*/, ::rsh::protocol::Function* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedGetFunction(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::rsh::protocol::FunctionRequest,::rsh::protocol::Function>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_GetContext<WithStreamedUnaryMethod_GetTypeFeedback<WithStreamedUnaryMethod_GetValues<WithStreamedUnaryMethod_GetFunction<Service > > > > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_GetContext<WithStreamedUnaryMethod_GetTypeFeedback<WithStreamedUnaryMethod_GetValues<WithStreamedUnaryMethod_GetFunction<Service > > > > StreamedService;
+};
+
+}  // namespace protocol
+}  // namespace rsh
+
+
+#endif  // GRPC_routes_2eproto__INCLUDED
diff --git a/client/rsh/src/routes.pb.cc b/client/rsh/src/routes.pb.cc
index f4b140952..0ecc6ef9d 100644
--- a/client/rsh/src/routes.pb.cc
+++ b/client/rsh/src/routes.pb.cc
@@ -20,6 +20,10 @@ PROTOBUF_PRAGMA_INIT_SEG
 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
 namespace _pbi = _pb::internal;
 
+namespace rsh {
+namespace protocol {
+}  // namespace protocol
+}  // namespace rsh
 static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_routes_2eproto = nullptr;
 static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_routes_2eproto = nullptr;
 const uint32_t TableStruct_routes_2eproto::offsets[1] = {};
@@ -27,23 +31,27 @@ static constexpr ::_pbi::MigrationSchema* schemas = nullptr;
 static constexpr ::_pb::Message* const* file_default_instances = nullptr;
 
 const char descriptor_table_protodef_routes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
-  "\n\014routes.proto\032\016messages.proto2g\n\016Compil"
-  "eService\022.\n\007Compile\022\017.CompileRequest\032\020.C"
-  "ompileResponse\"\000\022%\n\004Init\022\014.InitRequest\032\r"
-  ".InitResponse\"\0002\303\001\n\013FactService\022)\n\nGetCo"
-  "ntext\022\017.ContextRequest\032\010.Context\"\000\0224\n\017Ge"
-  "tTypeFeedback\022\020.FeedbackRequest\032\r.TypeFe"
-  "edback\"\000\022%\n\tGetValues\022\r.ValueRequest\032\007.V"
-  "alues\"\000\022,\n\013GetFunction\022\020.FunctionRequest"
-  "\032\t.Function\"\000B\023\n\021org.prlprg.serverb\006prot"
-  "o3"
+  "\n\014routes.proto\022\014rsh.protocol\032\016messages.p"
+  "roto2\233\001\n\016CompileService\022H\n\007Compile\022\034.rsh"
+  ".protocol.CompileRequest\032\035.rsh.protocol."
+  "CompileResponse\"\000\022\?\n\004Init\022\031.rsh.protocol"
+  ".InitRequest\032\032.rsh.protocol.InitResponse"
+  "\"\0002\253\002\n\013FactService\022C\n\nGetContext\022\034.rsh.p"
+  "rotocol.ContextRequest\032\025.rsh.protocol.Co"
+  "ntext\"\000\022N\n\017GetTypeFeedback\022\035.rsh.protoco"
+  "l.FeedbackRequest\032\032.rsh.protocol.TypeFee"
+  "dback\"\000\022\?\n\tGetValues\022\032.rsh.protocol.Valu"
+  "eRequest\032\024.rsh.protocol.Values\"\000\022F\n\013GetF"
+  "unction\022\035.rsh.protocol.FunctionRequest\032\026"
+  ".rsh.protocol.Function\"\000B\023\n\021org.prlprg.s"
+  "erverb\006proto3"
   ;
 static const ::_pbi::DescriptorTable* const descriptor_table_routes_2eproto_deps[1] = {
   &::descriptor_table_messages_2eproto,
 };
 static ::_pbi::once_flag descriptor_table_routes_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_routes_2eproto = {
-    false, false, 362, descriptor_table_protodef_routes_2eproto,
+    false, false, 533, descriptor_table_protodef_routes_2eproto,
     "routes.proto",
     &descriptor_table_routes_2eproto_once, descriptor_table_routes_2eproto_deps, 1, 0,
     schemas, file_default_instances, TableStruct_routes_2eproto::offsets,
@@ -56,8 +64,12 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_routes_2
 
 // Force running AddDescriptors() at dynamic initialization time.
 PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_routes_2eproto(&descriptor_table_routes_2eproto);
+namespace rsh {
+namespace protocol {
 
 // @@protoc_insertion_point(namespace_scope)
+}  // namespace protocol
+}  // namespace rsh
 PROTOBUF_NAMESPACE_OPEN
 PROTOBUF_NAMESPACE_CLOSE
 
diff --git a/client/rsh/src/routes.pb.h b/client/rsh/src/routes.pb.h
index 471b9a9d8..c213b0242 100644
--- a/client/rsh/src/routes.pb.h
+++ b/client/rsh/src/routes.pb.h
@@ -45,6 +45,8 @@ struct TableStruct_routes_2eproto {
 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_routes_2eproto;
 PROTOBUF_NAMESPACE_OPEN
 PROTOBUF_NAMESPACE_CLOSE
+namespace rsh {
+namespace protocol {
 
 // ===================================================================
 
@@ -64,6 +66,8 @@ PROTOBUF_NAMESPACE_CLOSE
 
 // @@protoc_insertion_point(namespace_scope)
 
+}  // namespace protocol
+}  // namespace rsh
 
 // @@protoc_insertion_point(global_scope)
 
diff --git a/proto/Makefile b/proto/Makefile
index cef7b89dd..e85ca4aab 100644
--- a/proto/Makefile
+++ b/proto/Makefile
@@ -1,4 +1,5 @@
 CPP_DEST := ../client//rsh/src
 
 all:
-	protoc --cpp_out=$(CPP_DEST)  messages.proto routes.proto
\ No newline at end of file
+	protoc --cpp_out=$(CPP_DEST)  messages.proto routes.proto
+	protoc --grpc_out=$(CPP_DEST) --plugin=protoc-gen-grpc=`which grpc_cpp_plugin`  routes.proto
\ No newline at end of file
diff --git a/proto/messages.proto b/proto/messages.proto
index 952a1348d..5414eeb74 100644
--- a/proto/messages.proto
+++ b/proto/messages.proto
@@ -2,6 +2,8 @@ syntax = "proto3";
 
 option java_package = "org.prlprg.server";
 
+package rsh.protocol;
+
 // Error handling
 // grpc already has a way to handle errors
 // Status message: https://grpc.github.io/grpc-java/javadoc/io/grpc/Status.html
diff --git a/proto/routes.proto b/proto/routes.proto
index ac6775360..5a3208f7d 100644
--- a/proto/routes.proto
+++ b/proto/routes.proto
@@ -4,6 +4,8 @@ option java_package = "org.prlprg.server";
 
 import "messages.proto";
 
+package rsh.protocol;
+
 // R sends requests to the compile server
 service CompileService {
   rpc Compile(CompileRequest) returns (CompileResponse) {}
diff --git a/server/src/main/java/org/prlprg/rds/AltRep.java b/server/src/main/java/org/prlprg/rds/AltRep.java
index b0782d6e3..cee21c171 100644
--- a/server/src/main/java/org/prlprg/rds/AltRep.java
+++ b/server/src/main/java/org/prlprg/rds/AltRep.java
@@ -4,7 +4,7 @@
 import java.util.logging.Logger;
 import org.prlprg.sexp.*;
 
-interface AltRep {
+interface zAltRep {
   SEXPType getType();
 
   String getClassName();
diff --git a/server/src/main/java/org/prlprg/session/DESCRIPTION.java b/server/src/main/java/org/prlprg/session/DESCRIPTION.java
index a184423f1..5bf1336ae 100644
--- a/server/src/main/java/org/prlprg/session/DESCRIPTION.java
+++ b/server/src/main/java/org/prlprg/session/DESCRIPTION.java
@@ -1,10 +1,8 @@
-
 package org.prlprg.session;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.regex.Matcher;
@@ -12,88 +10,88 @@
 
 /** DESCRIPTION file parser. */
 public class DESCRIPTION {
-    private String version;
-    private final HashMap<String, String> suggests;
-    private final HashMap<String, String> imports;
+  private String version;
+  private final HashMap<String, String> suggests;
+  private final HashMap<String, String> imports;
 
-    private static final Pattern versionPattern = Pattern.compile("^Version:\\s*(.*)$");
-    private static final Pattern suggestsPattern = Pattern.compile("^Suggests:\\s*(.*)$");
-    private static final Pattern importsPattern = Pattern.compile("^Imports:\\s*(.*)$");
-    private static final Pattern versionRequirementPattern = Pattern.compile("([a-zA-Z0-9]+)\\s*\\((>=|=|>|<=|<)\\s*([0-9\\.]+)\\)");
+  private static final Pattern versionPattern = Pattern.compile("^Version:\\s*(.*)$");
+  private static final Pattern suggestsPattern = Pattern.compile("^Suggests:\\s*(.*)$");
+  private static final Pattern importsPattern = Pattern.compile("^Imports:\\s*(.*)$");
+  private static final Pattern versionRequirementPattern =
+      Pattern.compile("([a-zA-Z0-9]+)\\s*\\((>=|=|>|<=|<)\\s*([0-9\\.]+)\\)");
 
-    public DESCRIPTION(Path descriptionFile) throws IOException {
-        this.suggests = new HashMap<>();
-        this.imports = new HashMap<>();
-        parseDescriptionFile(descriptionFile);
-    }
+  public DESCRIPTION(Path descriptionFile) throws IOException {
+    this.suggests = new HashMap<>();
+    this.imports = new HashMap<>();
+    parseDescriptionFile(descriptionFile);
+  }
 
-    /**
-     * Parses the DESCRIPTION file.
-     *
-     * @param descriptionFile the path to the DESCRIPTION file
-     * @throws IOException if an I/O error occurs
-     */
-    private void parseDescriptionFile(Path descriptionFile) throws IOException {
-        List<String> lines = Files.readAllLines(descriptionFile);
+  /**
+   * Parses the DESCRIPTION file.
+   *
+   * @param descriptionFile the path to the DESCRIPTION file
+   * @throws IOException if an I/O error occurs
+   */
+  private void parseDescriptionFile(Path descriptionFile) throws IOException {
+    List<String> lines = Files.readAllLines(descriptionFile);
 
-        for (String line : lines) {
-            Matcher versionMatcher = versionPattern.matcher(line);
-            Matcher suggestsMatcher = suggestsPattern.matcher(line);
-            Matcher importsMatcher = importsPattern.matcher(line);
+    for (String line : lines) {
+      Matcher versionMatcher = versionPattern.matcher(line);
+      Matcher suggestsMatcher = suggestsPattern.matcher(line);
+      Matcher importsMatcher = importsPattern.matcher(line);
 
-            if (versionMatcher.find()) {
-                this.version = versionMatcher.group(1).trim();
-            } else if (suggestsMatcher.find()) {
-                parsePackages(suggestsMatcher.group(1).trim(), this.suggests);
-            } else if (importsMatcher.find()) {
-                parsePackages(importsMatcher.group(1).trim(), this.imports);
-            }
-        }
+      if (versionMatcher.find()) {
+        this.version = versionMatcher.group(1).trim();
+      } else if (suggestsMatcher.find()) {
+        parsePackages(suggestsMatcher.group(1).trim(), this.suggests);
+      } else if (importsMatcher.find()) {
+        parsePackages(importsMatcher.group(1).trim(), this.imports);
+      }
     }
+  }
 
-    /**
-     * Parses a comma-separated list of packages with version requirements.
-     *
-     * @param packages the comma-separated list of packages
-     * @param map the map to add the packages and their version requirements to
-     */
-    private void parsePackages(String packages, HashMap<String, String> map) {
-        String[] packageArray = packages.split(",");
-        for (String pkg : packageArray) {
-            Matcher matcher = versionRequirementPattern.matcher(pkg.trim());
-            if (matcher.find()) {
-                map.put(matcher.group(1).trim(), matcher.group(2).trim() + " " + matcher.group(3).trim());
-            } else {
-                map.put(pkg.trim(), "");
-            }
-        }
+  /**
+   * Parses a comma-separated list of packages with version requirements.
+   *
+   * @param packages the comma-separated list of packages
+   * @param map the map to add the packages and their version requirements to
+   */
+  private void parsePackages(String packages, HashMap<String, String> map) {
+    String[] packageArray = packages.split(",");
+    for (String pkg : packageArray) {
+      Matcher matcher = versionRequirementPattern.matcher(pkg.trim());
+      if (matcher.find()) {
+        map.put(matcher.group(1).trim(), matcher.group(2).trim() + " " + matcher.group(3).trim());
+      } else {
+        map.put(pkg.trim(), "");
+      }
     }
+  }
 
+  /**
+   * Returns the version of the package.
+   *
+   * @return the version of the package
+   */
+  public String getVersion() {
+    return version;
+  }
 
-    /**
-     * Returns the version of the package.
-     *
-     * @return the version of the package
-     */
-    public String getVersion() {
-        return version;
-    }
-
-    /**
-     * Returns the list of suggested packages.
-     *
-     * @return the list of suggested packages
-     */
-    public HashMap<String,String> getSuggests() {
-        return suggests;
-    }
+  /**
+   * Returns the list of suggested packages.
+   *
+   * @return the list of suggested packages
+   */
+  public HashMap<String, String> getSuggests() {
+    return suggests;
+  }
 
-    /**
-     * Returns the list of imported packages.
-     *
-     * @return the list of imported packages
-     */
-    public HashMap<String, String> getImports() {
-        return imports;
-    }
-}
\ No newline at end of file
+  /**
+   * Returns the list of imported packages.
+   *
+   * @return the list of imported packages
+   */
+  public HashMap<String, String> getImports() {
+    return imports;
+  }
+}
diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index 344b0421e..28be3794d 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -1,4 +1,3 @@
-
 package org.prlprg.session;
 
 import java.io.IOException;
@@ -22,7 +21,7 @@ class DummySession implements RSession {
   private final Logger logger = Logger.getLogger(DummySession.class.getName());
   private final GlobalEnvSXP globalEnv = new GlobalEnvSXP(SEXPs.EMPTY_ENV);
   private final NamespaceEnvSXP namespaceEnv =
-          new NamespaceEnvSXP("base", "4.3.2", globalEnv, new HashMap<>());
+      new NamespaceEnvSXP("base", "4.3.2", globalEnv, new HashMap<>());
   private final BaseEnvSXP baseEnv = new BaseEnvSXP(new HashMap<>());
 
   @Override
@@ -97,7 +96,7 @@ public void loadPackage(String name, String version) {
     String installedVersion = description.getVersion();
     if (!version.equals(installedVersion)) {
       throw new RuntimeException(
-              "Version mismatch: expected " + version + " but found " + installedVersion);
+          "Version mismatch: expected " + version + " but found " + installedVersion);
     }
 
     // Use suggests and imports as needed
@@ -129,8 +128,8 @@ private DESCRIPTION getDescription(String name) {
       // Check if package is installed and if not install it
       try {
         ProcessBuilder processBuilder =
-                new ProcessBuilder(
-                        "Rscript", "-e", "install.packages('" + name + "', repos='" + cranMirror + "')");
+            new ProcessBuilder(
+                "Rscript", "-e", "install.packages('" + name + "', repos='" + cranMirror + "')");
         processBuilder.inheritIO();
         Process process = processBuilder.start();
         int exitCode = process.waitFor();
@@ -153,7 +152,7 @@ private DESCRIPTION getDescription(String name) {
   }
 
   private static HashMap<String, SEXP> readPackageDatabase(
-          RSession session, Path libPath, String packageName) throws IOException {
+      RSession session, Path libPath, String packageName) throws IOException {
     var db = new PackageDatabase(session, libPath, packageName);
     return db.getBindings();
   }
@@ -197,14 +196,14 @@ public EnvSXP loadPackage(String name, String version, List<Messages.Function> f
 
     var bindings = new HashMap<String, SEXP>(functions.size());
     functions.forEach(
-            function -> {
-              try {
-                bindings.put(
-                        function.getName(), (CloSXP) RDSReader.readByteString(this, function.getBody()));
-              } catch (IOException e) {
-                throw new RuntimeException(e);
-              }
-            });
+        function -> {
+          try {
+            bindings.put(
+                function.getName(), (CloSXP) RDSReader.readByteString(this, function.getBody()));
+          } catch (IOException e) {
+            throw new RuntimeException(e);
+          }
+        });
     return new NamespaceEnvSXP(name, version, baseNamespace, bindings);
   }
 
diff --git a/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java b/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
index 06ab1e111..4dbe7a214 100644
--- a/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
+++ b/server/src/test/java/org/prlprg/rsession/DESCRIPTIONTest.java
@@ -1,82 +1,81 @@
 package org.prlprg.rsession;
 
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-import org.prlprg.session.DESCRIPTION;
-
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Map;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.prlprg.session.DESCRIPTION;
 
 public class DESCRIPTIONTest {
 
-    @TempDir Path tempDir;
-
-    @Test
-    public void testDescriptionParsing() throws IOException {
-        // Create a temporary DESCRIPTION file
-        Path descriptionFile = tempDir.resolve("DESCRIPTION");
-        Files.writeString(
-                descriptionFile,
-                "Package: testpkg\nVersion: 1.2.3\nSuggests: pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
-
-        // Parse the DESCRIPTION file
-        DESCRIPTION description = new DESCRIPTION(descriptionFile);
-
-        // Assert the parsed values
-        Assertions.assertEquals("1.2.3", description.getVersion());
-        Assertions.assertEquals(Map.of("pkgA", ">= 1.0.0", "pkgB", ""), description.getSuggests());
-        Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
-    }
-
-    @Test
-    public void testEmptySuggestsAndImports() throws IOException {
-        // Create a temporary DESCRIPTION file
-        Path descriptionFile = tempDir.resolve("DESCRIPTION");
-        Files.writeString(descriptionFile, "Package: testpkg\nVersion: 1.2.3\n");
-
-        // Parse the DESCRIPTION file
-        DESCRIPTION description = new DESCRIPTION(descriptionFile);
-
-        // Assert the parsed values
-        Assertions.assertEquals("1.2.3", description.getVersion());
-        Assertions.assertTrue(description.getSuggests().isEmpty());
-        Assertions.assertTrue(description.getImports().isEmpty());
-    }
-
-    @Test
-    public void testNoVersion() throws IOException {
-        // Create a temporary DESCRIPTION file
-        Path descriptionFile = tempDir.resolve("DESCRIPTION");
-        Files.writeString(
-                descriptionFile,
-                "Package: testpkg\nSuggests: pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
-
-        // Parse the DESCRIPTION file
-        DESCRIPTION description = new DESCRIPTION(descriptionFile);
-
-        // Assert the parsed values
-        Assertions.assertNull(description.getVersion());
-        Assertions.assertEquals(Map.of("pkgA", ">= 1.0.0", "pkgB", ""), description.getSuggests());
-        Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
-    }
-
-    @Test
-    public void testMalformedDescription() throws IOException {
-        // Create a temporary DESCRIPTION file
-        Path descriptionFile = tempDir.resolve("DESCRIPTION");
-        Files.writeString(
-                descriptionFile,
-                "Package: testpkg\nVersion: 1.2.3\nSuggests pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
-
-        // Parse the DESCRIPTION file
-        DESCRIPTION description = new DESCRIPTION(descriptionFile);
-
-        // Assert the parsed values
-        Assertions.assertEquals("1.2.3", description.getVersion());
-        Assertions.assertTrue(description.getSuggests().isEmpty());
-        Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
-    }
-}
\ No newline at end of file
+  @TempDir Path tempDir;
+
+  @Test
+  public void testDescriptionParsing() throws IOException {
+    // Create a temporary DESCRIPTION file
+    Path descriptionFile = tempDir.resolve("DESCRIPTION");
+    Files.writeString(
+        descriptionFile,
+        "Package: testpkg\nVersion: 1.2.3\nSuggests: pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
+
+    // Parse the DESCRIPTION file
+    DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+    // Assert the parsed values
+    Assertions.assertEquals("1.2.3", description.getVersion());
+    Assertions.assertEquals(Map.of("pkgA", ">= 1.0.0", "pkgB", ""), description.getSuggests());
+    Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
+  }
+
+  @Test
+  public void testEmptySuggestsAndImports() throws IOException {
+    // Create a temporary DESCRIPTION file
+    Path descriptionFile = tempDir.resolve("DESCRIPTION");
+    Files.writeString(descriptionFile, "Package: testpkg\nVersion: 1.2.3\n");
+
+    // Parse the DESCRIPTION file
+    DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+    // Assert the parsed values
+    Assertions.assertEquals("1.2.3", description.getVersion());
+    Assertions.assertTrue(description.getSuggests().isEmpty());
+    Assertions.assertTrue(description.getImports().isEmpty());
+  }
+
+  @Test
+  public void testNoVersion() throws IOException {
+    // Create a temporary DESCRIPTION file
+    Path descriptionFile = tempDir.resolve("DESCRIPTION");
+    Files.writeString(
+        descriptionFile,
+        "Package: testpkg\nSuggests: pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
+
+    // Parse the DESCRIPTION file
+    DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+    // Assert the parsed values
+    Assertions.assertNull(description.getVersion());
+    Assertions.assertEquals(Map.of("pkgA", ">= 1.0.0", "pkgB", ""), description.getSuggests());
+    Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
+  }
+
+  @Test
+  public void testMalformedDescription() throws IOException {
+    // Create a temporary DESCRIPTION file
+    Path descriptionFile = tempDir.resolve("DESCRIPTION");
+    Files.writeString(
+        descriptionFile,
+        "Package: testpkg\nVersion: 1.2.3\nSuggests pkgA (>= 1.0.0), pkgB\nImports: pkgC, pkgD (>= 2.0.0)\n");
+
+    // Parse the DESCRIPTION file
+    DESCRIPTION description = new DESCRIPTION(descriptionFile);
+
+    // Assert the parsed values
+    Assertions.assertEquals("1.2.3", description.getVersion());
+    Assertions.assertTrue(description.getSuggests().isEmpty());
+    Assertions.assertEquals(Map.of("pkgC", "", "pkgD", ">= 2.0.0"), description.getImports());
+  }
+}
diff --git a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 6da9cb075..43b659f1b 100644
--- a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -1,4 +1,3 @@
-
 package org.prlprg.rsession;
 
 import java.io.IOException;
@@ -43,10 +42,10 @@ public void testVersionMismatch() {
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
     Assertions.assertThrows(
-            RuntimeException.class,
-            () -> {
-              session.loadPackage("yaml", "1.0.0");
-            });
+        RuntimeException.class,
+        () -> {
+          session.loadPackage("yaml", "1.0.0");
+        });
   }
 
   @Test
@@ -57,10 +56,10 @@ public void testLoadNonInstalledPackage() throws IOException, InterruptedExcepti
 
     // Assuming "nonexistentpkg" is not installed
     Assertions.assertThrows(
-            RuntimeException.class,
-            () -> {
-              session.loadPackage("nonexistentpkg", "1.0.0");
-            });
+        RuntimeException.class,
+        () -> {
+          session.loadPackage("nonexistentpkg", "1.0.0");
+        });
   }
 
   @Test
@@ -84,9 +83,9 @@ public void testMissingDescriptionFile() {
 
     // Assuming "pkgwithnomissingdesc" has no DESCRIPTION file
     Assertions.assertThrows(
-            RuntimeException.class,
-            () -> {
-              session.loadPackage("pkgwithnomissingdesc", "1.0.0");
-            });
+        RuntimeException.class,
+        () -> {
+          session.loadPackage("pkgwithnomissingdesc", "1.0.0");
+        });
   }
 }

From cc0a45d259a112374f666986481aebc09eb29185 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 3 Sep 2024 16:41:47 +0200
Subject: [PATCH 41/80] Now compiles and connects to the server.

WIP: do not only compile but also init the session
---
 client/rsh/R/rsh.R                            |  10 ++
 client/rsh/src/Makevars                       |   4 +-
 client/rsh/src/client.cpp                     |  40 ++++-
 client/rsh/src/client.h                       |   9 ++
 client/rsh/src/compiler.cpp                   |  24 +--
 client/rsh/src/init.cpp                       |   2 +
 client/rsh/src/messages.pb.cc                 | 148 +++++++++---------
 client/rsh/src/messages.pb.h                  |  94 +++++------
 proto/messages.proto                          |   2 +-
 .../src/main/java/org/prlprg/rds/AltRep.java  |   2 +-
 .../java/org/prlprg/session/GNURSession.java  |   4 +-
 11 files changed, 198 insertions(+), 141 deletions(-)

diff --git a/client/rsh/R/rsh.R b/client/rsh/R/rsh.R
index d481b70a2..567341da6 100644
--- a/client/rsh/R/rsh.R
+++ b/client/rsh/R/rsh.R
@@ -11,6 +11,16 @@ NULL
 .onLoad <- function(libname, pkgname) {
   # TODO: it would be great to make this go away and initialize this in C
   .Call(C_initialize, C_call_fun)
+  init_client("0.0.0.0", 8980L)
+}
+
+#' Initialize the Rsh client
+#' 
+#' @param IP address of the server
+#' @param port port of the server
+#' @export
+init_client <- function(address, port) {
+  .Call(C_init_client, address, port, installed.packages()[,1])
 }
 
 #' Activate the Rsh JIT
diff --git a/client/rsh/src/Makevars b/client/rsh/src/Makevars
index ce1a01b00..6e76c346c 100644
--- a/client/rsh/src/Makevars
+++ b/client/rsh/src/Makevars
@@ -5,8 +5,8 @@ LLVM_LIBS != $(LLVM_CONFIG) --libs
 
 PB_CPPFLAGS != pkg-config --cflags protobuf
 PB_LIBS != pkg-config --libs protobuf
-GRPC_CPPFLAGS != pkg-config --cflags grpc 
-GRPC_LIBS != pkg-config --libs grpc
+GRPC_CPPFLAGS != pkg-config --cflags grpc++
+GRPC_LIBS != pkg-config --libs grpc++
 
 PKG_CPPFLAGS := $(LLVM_CPPFLAGS) $(PB_CPPFLAGS) $(GRPC_CPPFLAGS) -fexceptions -I../inst -DR_NO_REMAP -DSTRICT_R_HEADERS
 PKG_LIBS := $(LLVM_LIBS) $(PB_LIBS) $(GRPC_LIBS) -lzmq
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 38595a05f..c199c72a9 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -22,7 +22,7 @@ Client::Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string>
     request.mutable_r_version()->set_minor(R_VERSION % 65536 / 256);
     request.mutable_r_version()->set_patch(R_VERSION % 256);
 
-    SEXP r_platform = Rf_eval(Rf_lang1(Rf_install("R.version")), R_BaseEnv);
+    SEXP r_platform = Rf_findVar(Rf_install("R.version"), R_BaseEnv);
     // we could also extract the R version from there
     // the platform is R.version$platform and is the st element of the list
     request.set_platform(CHAR(STRING_ELT(VECTOR_ELT(r_platform, 0), 0))); // or R_PLATFORM?
@@ -76,7 +76,7 @@ protocol::CompileResponse Client::remote_compile(std::string const& name,
   }
 }
 
-SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
+SEXP Client::make_client(SEXP address, SEXP port, SEXP installed_packages) {
   auto addr = CHAR(STRING_ELT(address, 0));
   auto p = INTEGER(port)[0];
   std::string address_str(addr);
@@ -89,8 +89,40 @@ SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
 
   auto channel = grpc::CreateChannel(address_str, grpc::InsecureChannelCredentials());
   auto client = new Client(channel, packages);
-  // TODO: we should also store that in a global variable as for CMP_FUN
-  return R_MakeExternalPtr(client, Rf_install("RSH_CLIENT"), R_NilValue);
+
+  
+  SEXP ptr =  PROTECT(R_MakeExternalPtr(client, Rf_install("RSH_CLIENT"), R_NilValue));
+  R_RegisterCFinalizerEx(ptr, &Client::remove_client, TRUE);// TRUE because we want to shutdown the client when R quits
+
+  UNPROTECT(1);
+  return ptr;
+}
+
+void Client::remove_client(SEXP ptr) {
+  if(ptr == nullptr) {
+    Rf_warning("Client already removed");
+  }
+  auto client = static_cast<Client*>(R_ExternalPtrAddr(ptr));
+  delete client;
+}
+
+Client* Client::get_client() {
+  if(Client::CLIENT_INSTANCE != nullptr) {
+    return static_cast<Client*>(R_ExternalPtrAddr(CLIENT_INSTANCE));
+  }
+  else {
+    Rf_error("Client not initialized");
+  }
+}
+
+SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
+  if(Client::CLIENT_INSTANCE != nullptr) {
+    Rf_warning("Client already initialized, replacing it");
+  }
+
+  Client::CLIENT_INSTANCE = Client::make_client(address, port, installed_packages);
+
+  return R_NilValue;
 }
 
 } // namespace rsh
diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index 850aebca9..b942ac323 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -18,6 +18,12 @@ namespace rsh {
 class Client {
 private:
   std::unique_ptr<protocol::CompileService::Stub> stub_;
+  static inline SEXP CLIENT_INSTANCE = nullptr;
+  static void remove_client(SEXP ptr);
+
+  // For it to be able to access the client instance
+  friend SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
+
 
 public:
   Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages);
@@ -26,6 +32,9 @@ class Client {
                                 std::vector<uint8_t> const &rds_closure,
                                 protocol::Tier tier,
                                 int32_t optimization_level);
+
+  static SEXP make_client(SEXP address, SEXP port, SEXP installed_packages);
+  static Client* get_client();
 };
 
 SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index b711d8130..461b16a3b 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -6,6 +6,7 @@
 #include <cstdio>
 #include <cstring>
 
+
 // clang-format off
 static i32 CALL_FUN_BC[] = {
   12,
@@ -34,16 +35,18 @@ SEXP CALL_FUN = nullptr;
 
 SEXP RSH_JIT_FUN_PTR = Rf_install("RSH_JIT_FUN_PTR");
 
-static CompileResponse compile_closure(std::string const &name, SEXP closure,
+static protocol::CompileResponse compile_closure(std::string const &name, SEXP closure,
                                        u32 opt_level = 3) {
   auto closure_bytes = rsh::serialize(closure);
-  return rsh::remote_compile(name, closure_bytes, opt_level);
+  auto client = rsh::Client::get_client();
+  return client->remote_compile(name, closure_bytes, protocol::Tier::OPTIMIZED, opt_level);
 }
 
-static void *insert_into_jit(CompiledFunction const &compiled_fun) {
-  auto native_code = compiled_fun.native_code();
+static void *insert_into_jit(protocol::CompileResponse const &compiled_fun) {
+  auto native_code = compiled_fun.code();
   GJIT->add_object(native_code);
-  auto ptr = GJIT->lookup(compiled_fun.name().c_str());
+  // TODO: we should have a map hash to name of the function here
+  auto ptr = GJIT->lookup(compiled_fun.hash().c_str());
   if (!ptr) {
     Rf_error("Unable to find the function in the JIT");
   }
@@ -51,12 +54,13 @@ static void *insert_into_jit(CompiledFunction const &compiled_fun) {
 }
 
 static SEXP create_constant_pool(void *fun_ptr,
-                                 CompiledFunction const &compiled_fun) {
+                                 protocol::CompileResponse const &compiled_fun) {
   auto pool = PROTECT(Rf_allocVector(VECSXP, 2));
 
   // create an external pointer to the JITed function with a finalizer
+  // TODO: we should have a map hash to name of the function here
   auto p = R_MakeExternalPtr(fun_ptr, RSH_JIT_FUN_PTR,
-                             Rf_mkString(compiled_fun.name().c_str()));
+                             Rf_mkString(compiled_fun.hash().c_str()));
   R_RegisterCFinalizerEx(p, &jit_fun_destructor, FALSE);
 
   // slot 0: the pointer to the compiled function
@@ -128,11 +132,11 @@ SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp) {
   sprintf(name_str, "%s_%p", closure_name, closure);
 
   auto response = compile_closure(name_str, closure, opt_level);
-  if (!response.has_result()) {
-    Rf_error("Compilation failed: %s", response.failure().c_str());
+  if (false) {// TODO: propagate error from the remote compilation
+    //Rf_error("Compilation failed: %s", response.failure().c_str());
     return closure;
   }
-  auto compiled_fun = response.result();
+  auto compiled_fun = response;
 
   auto fun_ptr = insert_into_jit(compiled_fun);
   SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, compiled_fun));
diff --git a/client/rsh/src/init.cpp b/client/rsh/src/init.cpp
index d0f3c50f4..e08599bf4 100644
--- a/client/rsh/src/init.cpp
+++ b/client/rsh/src/init.cpp
@@ -1,11 +1,13 @@
 #include <R_ext/Rdynload.h>
 
 #include "compiler.h"
+#include "client.h"
 
 extern "C" {
 static const R_CallMethodDef callMethods[] = {
     {"initialize", (DL_FUNC)&rsh::initialize, 1},
     {"compile_fun", (DL_FUNC)&rsh::compile_fun, 3},
+    {"init_client", (DL_FUNC)&rsh::init_client, 3},
     {NULL, NULL, 0}};
 
 static const R_ExternalMethodDef externalMethods[] = {
diff --git a/client/rsh/src/messages.pb.cc b/client/rsh/src/messages.pb.cc
index c726850e8..d04f1c58e 100644
--- a/client/rsh/src/messages.pb.cc
+++ b/client/rsh/src/messages.pb.cc
@@ -88,7 +88,7 @@ PROTOBUF_CONSTEXPR CompileResponse::CompileResponse(
   , /*decltype(_impl_._cached_size_)*/{}
   , /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
   , /*decltype(_impl_.code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.constant_pool_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.constants_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
   , /*decltype(_impl_.tier_)*/0} {}
 struct CompileResponseDefaultTypeInternal {
   PROTOBUF_CONSTEXPR CompileResponseDefaultTypeInternal()
@@ -460,7 +460,7 @@ const uint32_t TableStruct_messages_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE
   PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.hash_),
   PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.tier_),
   PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.code_),
-  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.constant_pool_),
+  PROTOBUF_FIELD_OFFSET(::rsh::protocol::CompileResponse, _impl_.constants_),
   ~0u,
   ~0u,
   0,
@@ -735,61 +735,61 @@ const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABL
   ".protocol.ContextH\002\210\001\001\0223\n\013environment\030\007 "
   "\001(\0132\031.rsh.protocol.EnvironmentH\003\210\001\001B\007\n\005_"
   "tierB\025\n\023_optimization_levelB\n\n\010_contextB"
-  "\016\n\014_environment\"\213\001\n\017CompileResponse\022\014\n\004h"
+  "\016\n\014_environment\"\203\001\n\017CompileResponse\022\014\n\004h"
   "ash\030\001 \001(\014\022 \n\004tier\030\002 \001(\0162\022.rsh.protocol.T"
-  "ier\022\021\n\004code\030\003 \001(\014H\000\210\001\001\022\032\n\rconstant_pool\030"
-  "\004 \001(\014H\001\210\001\001B\007\n\005_codeB\020\n\016_constant_pool\"X\n"
-  "\010Function\022\024\n\014package_hash\030\001 \001(\014\022\014\n\004name\030"
-  "\002 \001(\t\022\014\n\004hash\030\003 \001(\014\022\021\n\004body\030\004 \001(\014H\000\210\001\001B\007"
-  "\n\005_body\"\037\n\017FunctionRequest\022\014\n\004hash\030\001 \001(\014"
-  "\"s\n\013Environment\0225\n\006values\030\001 \003(\0132%.rsh.pr"
-  "otocol.Environment.ValuesEntry\032-\n\013Values"
-  "Entry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014:\0028\001\"\034\n"
-  "\014ValueRequest\022\014\n\004hash\030\001 \003(\014\"$\n\005Value\022\014\n\004"
-  "hash\030\001 \001(\014\022\r\n\005value\030\002 \001(\014\"-\n\006Values\022#\n\006v"
-  "alues\030\001 \003(\0132\023.rsh.protocol.Value\"\007\n\005Empt"
-  "y\"\206\001\n\013CallContext\022\037\n\027args_statically_mat"
-  "ched\030\001 \001(\010\022\036\n\026correct_number_of_args\030\002 \001"
-  "(\010\022\035\n\025correct_order_of_args\030\003 \001(\010\022\027\n\017no_"
-  "missing_args\030\004 \001(\010\"t\n\017ArgumentContext\022\r\n"
-  "\005eager\030\001 \001(\010\022\022\n\nreflection\030\002 \001(\010\022\016\n\006obje"
-  "ct\030\003 \001(\010\022%\n\004type\030\004 \001(\0162\022.rsh.protocol.Ty"
-  "peH\000\210\001\001B\007\n\005_type\"s\n\007Context\022/\n\014call_cont"
-  "ext\030\001 \001(\0132\031.rsh.protocol.CallContext\0227\n\020"
-  "argument_context\030\002 \003(\0132\035.rsh.protocol.Ar"
-  "gumentContext\":\n\016ContextRequest\022(\n\010funct"
-  "ion\030\001 \001(\0132\026.rsh.protocol.Function\"\?\n\014Tes"
-  "tFeedback\022/\n\014test_lattice\030\001 \001(\0162\031.rsh.pr"
-  "otocol.TestLattice\"4\n\014CallFeedback\022\017\n\007n_"
-  "calls\030\001 \001(\003\022\023\n\013callee_hash\030\002 \001(\014\"v\n\rValu"
-  "eFeedback\022\016\n\006scalar\030\001 \001(\010\022\016\n\006object\030\002 \001("
-  "\010\022\033\n\023accessed_attributes\030\003 \001(\010\022\024\n\014vector"
-  "izable\030\004 \001(\010\022\022\n\nis_promise\030\005 \001(\010\"\321\002\n\014Typ"
-  "eFeedback\0224\n\005types\030\002 \003(\0132%.rsh.protocol."
-  "TypeFeedback.TypesEntry\032\267\001\n\010Feedback\0223\n\r"
-  "test_feedback\030\001 \001(\0132\032.rsh.protocol.TestF"
-  "eedbackH\000\0223\n\rcall_feedback\030\002 \001(\0132\032.rsh.p"
-  "rotocol.CallFeedbackH\000\0225\n\016value_feedback"
-  "\030\003 \001(\0132\033.rsh.protocol.ValueFeedbackH\000B\n\n"
-  "\010feedback\032Q\n\nTypesEntry\022\013\n\003key\030\001 \001(\003\0222\n\005"
-  "value\030\002 \001(\0132#.rsh.protocol.TypeFeedback."
-  "Feedback:\0028\001\";\n\017FeedbackRequest\022(\n\010funct"
-  "ion\030\001 \001(\0132\026.rsh.protocol.Function\"C\n\rPac"
-  "kageSource\022\022\n\010r_mirror\030\002 \001(\tH\000\022\024\n\ngithub"
-  "_url\030\003 \001(\tH\000B\010\n\006source\"\225\001\n\007Package\022\014\n\004na"
-  "me\030\001 \001(\t\022&\n\007version\030\002 \001(\0132\025.rsh.protocol"
-  ".Version\022\027\n\017function_hashes\030\004 \003(\014\0220\n\006sou"
-  "rce\030\005 \001(\0132\033.rsh.protocol.PackageSourceH\000"
-  "\210\001\001B\t\n\007_source\"\036\n\016PackageRequest\022\014\n\004hash"
-  "\030\001 \001(\014*#\n\004Tier\022\014\n\010BASELINE\020\000\022\r\n\tOPTIMIZE"
-  "D\020\001*@\n\013TestLattice\022\010\n\004BOTH\020\000\022\r\n\tONLY_TRU"
-  "E\020\001\022\016\n\nONLY_FALSE\020\002\022\010\n\004NONE\020\003*&\n\004Type\022\007\n"
-  "\003ANY\020\000\022\013\n\007INTEGER\020\001\022\010\n\004REAL\020\002B\023\n\021org.prl"
-  "prg.serverb\006proto3"
+  "ier\022\021\n\004code\030\003 \001(\014H\000\210\001\001\022\026\n\tconstants\030\004 \001("
+  "\014H\001\210\001\001B\007\n\005_codeB\014\n\n_constants\"X\n\010Functio"
+  "n\022\024\n\014package_hash\030\001 \001(\014\022\014\n\004name\030\002 \001(\t\022\014\n"
+  "\004hash\030\003 \001(\014\022\021\n\004body\030\004 \001(\014H\000\210\001\001B\007\n\005_body\""
+  "\037\n\017FunctionRequest\022\014\n\004hash\030\001 \001(\014\"s\n\013Envi"
+  "ronment\0225\n\006values\030\001 \003(\0132%.rsh.protocol.E"
+  "nvironment.ValuesEntry\032-\n\013ValuesEntry\022\013\n"
+  "\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014:\0028\001\"\034\n\014ValueRe"
+  "quest\022\014\n\004hash\030\001 \003(\014\"$\n\005Value\022\014\n\004hash\030\001 \001"
+  "(\014\022\r\n\005value\030\002 \001(\014\"-\n\006Values\022#\n\006values\030\001 "
+  "\003(\0132\023.rsh.protocol.Value\"\007\n\005Empty\"\206\001\n\013Ca"
+  "llContext\022\037\n\027args_statically_matched\030\001 \001"
+  "(\010\022\036\n\026correct_number_of_args\030\002 \001(\010\022\035\n\025co"
+  "rrect_order_of_args\030\003 \001(\010\022\027\n\017no_missing_"
+  "args\030\004 \001(\010\"t\n\017ArgumentContext\022\r\n\005eager\030\001"
+  " \001(\010\022\022\n\nreflection\030\002 \001(\010\022\016\n\006object\030\003 \001(\010"
+  "\022%\n\004type\030\004 \001(\0162\022.rsh.protocol.TypeH\000\210\001\001B"
+  "\007\n\005_type\"s\n\007Context\022/\n\014call_context\030\001 \001("
+  "\0132\031.rsh.protocol.CallContext\0227\n\020argument"
+  "_context\030\002 \003(\0132\035.rsh.protocol.ArgumentCo"
+  "ntext\":\n\016ContextRequest\022(\n\010function\030\001 \001("
+  "\0132\026.rsh.protocol.Function\"\?\n\014TestFeedbac"
+  "k\022/\n\014test_lattice\030\001 \001(\0162\031.rsh.protocol.T"
+  "estLattice\"4\n\014CallFeedback\022\017\n\007n_calls\030\001 "
+  "\001(\003\022\023\n\013callee_hash\030\002 \001(\014\"v\n\rValueFeedbac"
+  "k\022\016\n\006scalar\030\001 \001(\010\022\016\n\006object\030\002 \001(\010\022\033\n\023acc"
+  "essed_attributes\030\003 \001(\010\022\024\n\014vectorizable\030\004"
+  " \001(\010\022\022\n\nis_promise\030\005 \001(\010\"\321\002\n\014TypeFeedbac"
+  "k\0224\n\005types\030\002 \003(\0132%.rsh.protocol.TypeFeed"
+  "back.TypesEntry\032\267\001\n\010Feedback\0223\n\rtest_fee"
+  "dback\030\001 \001(\0132\032.rsh.protocol.TestFeedbackH"
+  "\000\0223\n\rcall_feedback\030\002 \001(\0132\032.rsh.protocol."
+  "CallFeedbackH\000\0225\n\016value_feedback\030\003 \001(\0132\033"
+  ".rsh.protocol.ValueFeedbackH\000B\n\n\010feedbac"
+  "k\032Q\n\nTypesEntry\022\013\n\003key\030\001 \001(\003\0222\n\005value\030\002 "
+  "\001(\0132#.rsh.protocol.TypeFeedback.Feedback"
+  ":\0028\001\";\n\017FeedbackRequest\022(\n\010function\030\001 \001("
+  "\0132\026.rsh.protocol.Function\"C\n\rPackageSour"
+  "ce\022\022\n\010r_mirror\030\002 \001(\tH\000\022\024\n\ngithub_url\030\003 \001"
+  "(\tH\000B\010\n\006source\"\225\001\n\007Package\022\014\n\004name\030\001 \001(\t"
+  "\022&\n\007version\030\002 \001(\0132\025.rsh.protocol.Version"
+  "\022\027\n\017function_hashes\030\004 \003(\014\0220\n\006source\030\005 \001("
+  "\0132\033.rsh.protocol.PackageSourceH\000\210\001\001B\t\n\007_"
+  "source\"\036\n\016PackageRequest\022\014\n\004hash\030\001 \001(\014*#"
+  "\n\004Tier\022\014\n\010BASELINE\020\000\022\r\n\tOPTIMIZED\020\001*@\n\013T"
+  "estLattice\022\010\n\004BOTH\020\000\022\r\n\tONLY_TRUE\020\001\022\016\n\nO"
+  "NLY_FALSE\020\002\022\010\n\004NONE\020\003*&\n\004Type\022\007\n\003ANY\020\000\022\013"
+  "\n\007INTEGER\020\001\022\010\n\004REAL\020\002B\023\n\021org.prlprg.serv"
+  "erb\006proto3"
   ;
 static ::_pbi::once_flag descriptor_table_messages_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_messages_2eproto = {
-    false, false, 2538, descriptor_table_protodef_messages_2eproto,
+    false, false, 2530, descriptor_table_protodef_messages_2eproto,
     "messages.proto",
     &descriptor_table_messages_2eproto_once, nullptr, 0, 27,
     schemas, file_default_instances, TableStruct_messages_2eproto::offsets,
@@ -1827,7 +1827,7 @@ class CompileResponse::_Internal {
   static void set_has_code(HasBits* has_bits) {
     (*has_bits)[0] |= 1u;
   }
-  static void set_has_constant_pool(HasBits* has_bits) {
+  static void set_has_constants(HasBits* has_bits) {
     (*has_bits)[0] |= 2u;
   }
 };
@@ -1846,7 +1846,7 @@ CompileResponse::CompileResponse(const CompileResponse& from)
     , /*decltype(_impl_._cached_size_)*/{}
     , decltype(_impl_.hash_){}
     , decltype(_impl_.code_){}
-    , decltype(_impl_.constant_pool_){}
+    , decltype(_impl_.constants_){}
     , decltype(_impl_.tier_){}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
@@ -1866,12 +1866,12 @@ CompileResponse::CompileResponse(const CompileResponse& from)
     _this->_impl_.code_.Set(from._internal_code(), 
       _this->GetArenaForAllocation());
   }
-  _impl_.constant_pool_.InitDefault();
+  _impl_.constants_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+    _impl_.constants_.Set("", GetArenaForAllocation());
   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (from._internal_has_constant_pool()) {
-    _this->_impl_.constant_pool_.Set(from._internal_constant_pool(), 
+  if (from._internal_has_constants()) {
+    _this->_impl_.constants_.Set(from._internal_constants(), 
       _this->GetArenaForAllocation());
   }
   _this->_impl_.tier_ = from._impl_.tier_;
@@ -1887,7 +1887,7 @@ inline void CompileResponse::SharedCtor(
     , /*decltype(_impl_._cached_size_)*/{}
     , decltype(_impl_.hash_){}
     , decltype(_impl_.code_){}
-    , decltype(_impl_.constant_pool_){}
+    , decltype(_impl_.constants_){}
     , decltype(_impl_.tier_){0}
   };
   _impl_.hash_.InitDefault();
@@ -1898,9 +1898,9 @@ inline void CompileResponse::SharedCtor(
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.code_.Set("", GetArenaForAllocation());
   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.constant_pool_.InitDefault();
+  _impl_.constants_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+    _impl_.constants_.Set("", GetArenaForAllocation());
   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
@@ -1917,7 +1917,7 @@ inline void CompileResponse::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
   _impl_.hash_.Destroy();
   _impl_.code_.Destroy();
-  _impl_.constant_pool_.Destroy();
+  _impl_.constants_.Destroy();
 }
 
 void CompileResponse::SetCachedSize(int size) const {
@@ -1937,7 +1937,7 @@ void CompileResponse::Clear() {
       _impl_.code_.ClearNonDefaultToEmpty();
     }
     if (cached_has_bits & 0x00000002u) {
-      _impl_.constant_pool_.ClearNonDefaultToEmpty();
+      _impl_.constants_.ClearNonDefaultToEmpty();
     }
   }
   _impl_.tier_ = 0;
@@ -1979,10 +1979,10 @@ const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContex
         } else
           goto handle_unusual;
         continue;
-      // optional bytes constant_pool = 4;
+      // optional bytes constants = 4;
       case 4:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
-          auto str = _internal_mutable_constant_pool();
+          auto str = _internal_mutable_constants();
           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
           CHK_(ptr);
         } else
@@ -2037,10 +2037,10 @@ uint8_t* CompileResponse::_InternalSerialize(
         3, this->_internal_code(), target);
   }
 
-  // optional bytes constant_pool = 4;
-  if (_internal_has_constant_pool()) {
+  // optional bytes constants = 4;
+  if (_internal_has_constants()) {
     target = stream->WriteBytesMaybeAliased(
-        4, this->_internal_constant_pool(), target);
+        4, this->_internal_constants(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -2075,11 +2075,11 @@ size_t CompileResponse::ByteSizeLong() const {
           this->_internal_code());
     }
 
-    // optional bytes constant_pool = 4;
+    // optional bytes constants = 4;
     if (cached_has_bits & 0x00000002u) {
       total_size += 1 +
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-          this->_internal_constant_pool());
+          this->_internal_constants());
     }
 
   }
@@ -2116,7 +2116,7 @@ void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
       _this->_internal_set_code(from._internal_code());
     }
     if (cached_has_bits & 0x00000002u) {
-      _this->_internal_set_constant_pool(from._internal_constant_pool());
+      _this->_internal_set_constants(from._internal_constants());
     }
   }
   if (from._internal_tier() != 0) {
@@ -2151,8 +2151,8 @@ void CompileResponse::InternalSwap(CompileResponse* other) {
       &other->_impl_.code_, rhs_arena
   );
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.constant_pool_, lhs_arena,
-      &other->_impl_.constant_pool_, rhs_arena
+      &_impl_.constants_, lhs_arena,
+      &other->_impl_.constants_, rhs_arena
   );
   swap(_impl_.tier_, other->_impl_.tier_);
 }
diff --git a/client/rsh/src/messages.pb.h b/client/rsh/src/messages.pb.h
index 3f8caf8b4..3a58a1600 100644
--- a/client/rsh/src/messages.pb.h
+++ b/client/rsh/src/messages.pb.h
@@ -1104,7 +1104,7 @@ class CompileResponse final :
   enum : int {
     kHashFieldNumber = 1,
     kCodeFieldNumber = 3,
-    kConstantPoolFieldNumber = 4,
+    kConstantsFieldNumber = 4,
     kTierFieldNumber = 2,
   };
   // bytes hash = 1;
@@ -1139,22 +1139,22 @@ class CompileResponse final :
   std::string* _internal_mutable_code();
   public:
 
-  // optional bytes constant_pool = 4;
-  bool has_constant_pool() const;
+  // optional bytes constants = 4;
+  bool has_constants() const;
   private:
-  bool _internal_has_constant_pool() const;
+  bool _internal_has_constants() const;
   public:
-  void clear_constant_pool();
-  const std::string& constant_pool() const;
+  void clear_constants();
+  const std::string& constants() const;
   template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_constant_pool(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_constant_pool();
-  PROTOBUF_NODISCARD std::string* release_constant_pool();
-  void set_allocated_constant_pool(std::string* constant_pool);
+  void set_constants(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_constants();
+  PROTOBUF_NODISCARD std::string* release_constants();
+  void set_allocated_constants(std::string* constants);
   private:
-  const std::string& _internal_constant_pool() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_constant_pool(const std::string& value);
-  std::string* _internal_mutable_constant_pool();
+  const std::string& _internal_constants() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_constants(const std::string& value);
+  std::string* _internal_mutable_constants();
   public:
 
   // .rsh.protocol.Tier tier = 2;
@@ -1178,7 +1178,7 @@ class CompileResponse final :
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr code_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constant_pool_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constants_;
     int tier_;
   };
   union { Impl_ _impl_; };
@@ -5532,72 +5532,72 @@ inline void CompileResponse::set_allocated_code(std::string* code) {
   // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.code)
 }
 
-// optional bytes constant_pool = 4;
-inline bool CompileResponse::_internal_has_constant_pool() const {
+// optional bytes constants = 4;
+inline bool CompileResponse::_internal_has_constants() const {
   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
   return value;
 }
-inline bool CompileResponse::has_constant_pool() const {
-  return _internal_has_constant_pool();
+inline bool CompileResponse::has_constants() const {
+  return _internal_has_constants();
 }
-inline void CompileResponse::clear_constant_pool() {
-  _impl_.constant_pool_.ClearToEmpty();
+inline void CompileResponse::clear_constants() {
+  _impl_.constants_.ClearToEmpty();
   _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const std::string& CompileResponse::constant_pool() const {
-  // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.constant_pool)
-  return _internal_constant_pool();
+inline const std::string& CompileResponse::constants() const {
+  // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.constants)
+  return _internal_constants();
 }
 template <typename ArgT0, typename... ArgT>
 inline PROTOBUF_ALWAYS_INLINE
-void CompileResponse::set_constant_pool(ArgT0&& arg0, ArgT... args) {
+void CompileResponse::set_constants(ArgT0&& arg0, ArgT... args) {
  _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.constant_pool_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.constant_pool)
+ _impl_.constants_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.constants)
 }
-inline std::string* CompileResponse::mutable_constant_pool() {
-  std::string* _s = _internal_mutable_constant_pool();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileResponse.constant_pool)
+inline std::string* CompileResponse::mutable_constants() {
+  std::string* _s = _internal_mutable_constants();
+  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileResponse.constants)
   return _s;
 }
-inline const std::string& CompileResponse::_internal_constant_pool() const {
-  return _impl_.constant_pool_.Get();
+inline const std::string& CompileResponse::_internal_constants() const {
+  return _impl_.constants_.Get();
 }
-inline void CompileResponse::_internal_set_constant_pool(const std::string& value) {
+inline void CompileResponse::_internal_set_constants(const std::string& value) {
   _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.constant_pool_.Set(value, GetArenaForAllocation());
+  _impl_.constants_.Set(value, GetArenaForAllocation());
 }
-inline std::string* CompileResponse::_internal_mutable_constant_pool() {
+inline std::string* CompileResponse::_internal_mutable_constants() {
   _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.constant_pool_.Mutable(GetArenaForAllocation());
+  return _impl_.constants_.Mutable(GetArenaForAllocation());
 }
-inline std::string* CompileResponse::release_constant_pool() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.CompileResponse.constant_pool)
-  if (!_internal_has_constant_pool()) {
+inline std::string* CompileResponse::release_constants() {
+  // @@protoc_insertion_point(field_release:rsh.protocol.CompileResponse.constants)
+  if (!_internal_has_constants()) {
     return nullptr;
   }
   _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.constant_pool_.Release();
+  auto* p = _impl_.constants_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.constant_pool_.IsDefault()) {
-    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+  if (_impl_.constants_.IsDefault()) {
+    _impl_.constants_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   return p;
 }
-inline void CompileResponse::set_allocated_constant_pool(std::string* constant_pool) {
-  if (constant_pool != nullptr) {
+inline void CompileResponse::set_allocated_constants(std::string* constants) {
+  if (constants != nullptr) {
     _impl_._has_bits_[0] |= 0x00000002u;
   } else {
     _impl_._has_bits_[0] &= ~0x00000002u;
   }
-  _impl_.constant_pool_.SetAllocated(constant_pool, GetArenaForAllocation());
+  _impl_.constants_.SetAllocated(constants, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.constant_pool_.IsDefault()) {
-    _impl_.constant_pool_.Set("", GetArenaForAllocation());
+  if (_impl_.constants_.IsDefault()) {
+    _impl_.constants_.Set("", GetArenaForAllocation());
   }
 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.constant_pool)
+  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.constants)
 }
 
 // -------------------------------------------------------------------
diff --git a/proto/messages.proto b/proto/messages.proto
index 5414eeb74..8270d6f73 100644
--- a/proto/messages.proto
+++ b/proto/messages.proto
@@ -39,7 +39,7 @@ message CompileResponse {
   bytes hash = 1;
   Tier tier = 2;
   optional bytes code = 3;
-  optional bytes constant_pool = 4;
+  optional bytes constants = 4;
 }
 
 
diff --git a/server/src/main/java/org/prlprg/rds/AltRep.java b/server/src/main/java/org/prlprg/rds/AltRep.java
index cee21c171..b0782d6e3 100644
--- a/server/src/main/java/org/prlprg/rds/AltRep.java
+++ b/server/src/main/java/org/prlprg/rds/AltRep.java
@@ -4,7 +4,7 @@
 import java.util.logging.Logger;
 import org.prlprg.sexp.*;
 
-interface zAltRep {
+interface AltRep {
   SEXPType getType();
 
   String getClassName();
diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index 28be3794d..53671ae43 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -100,8 +100,8 @@ public void loadPackage(String name, String version) {
     }
 
     // Use suggests and imports as needed
-    List<String> suggests = description.getSuggests();
-    List<String> imports = description.getImports();
+    var suggests = description.getSuggests();
+    var imports = description.getImports();
 
     // Make sure base is loaded
     if (baseNamespace == null) {

From 4c9470e0f993f7fb06d5a242b0fd9dc8dc2a508f Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 3 Sep 2024 17:50:40 +0200
Subject: [PATCH 42/80] Namespace for proto for the java version also

---
 server/src/main/proto/messages.proto | 1 +
 server/src/main/proto/routes.proto   | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/server/src/main/proto/messages.proto b/server/src/main/proto/messages.proto
index 952a1348d..36f8917ec 100644
--- a/server/src/main/proto/messages.proto
+++ b/server/src/main/proto/messages.proto
@@ -1,4 +1,5 @@
 syntax = "proto3";
+package rsh.protocol;
 
 option java_package = "org.prlprg.server";
 
diff --git a/server/src/main/proto/routes.proto b/server/src/main/proto/routes.proto
index ac6775360..d66b1201e 100644
--- a/server/src/main/proto/routes.proto
+++ b/server/src/main/proto/routes.proto
@@ -2,6 +2,8 @@ syntax = "proto3";
 
 option java_package = "org.prlprg.server";
 
+package rsh.protocol;
+
 import "messages.proto";
 
 // R sends requests to the compile server

From 8bb9d3bfeb9b3bf7a1b80b0917eae0b3cbc3c491 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 4 Sep 2024 15:11:35 +0200
Subject: [PATCH 43/80] Make it easier to test

---
 client/rsh/Makefile | 3 +++
 client/rsh/test3.R  | 2 +-
 client/rsh/test4.R  | 3 ++-
 client/rsh/test5.R  | 2 +-
 4 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/client/rsh/Makefile b/client/rsh/Makefile
index cfa57c153..6ca965cef 100644
--- a/client/rsh/Makefile
+++ b/client/rsh/Makefile
@@ -29,3 +29,6 @@ install:
 
 setup:
 	$(BEAR) -- $(MAKE) clean install
+
+test:
+	LD_PRELOAD=$(LLVM_LIB) ../../external/R/bin/R -f test5.R
\ No newline at end of file
diff --git a/client/rsh/test3.R b/client/rsh/test3.R
index 4dfb27ca1..de0c8a0f1 100644
--- a/client/rsh/test3.R
+++ b/client/rsh/test3.R
@@ -1,4 +1,4 @@
-dyn.load("../../../resources/R-4.3.2/library/rsh/libs/rsh.so", local = FALSE)
+dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
 
 f <- function(x) {
   y <- x + 42
diff --git a/client/rsh/test4.R b/client/rsh/test4.R
index f162bbd1a..392d9423d 100644
--- a/client/rsh/test4.R
+++ b/client/rsh/test4.R
@@ -1,4 +1,5 @@
-dyn.load("../../../resources/R-4.3.2/library/rsh/libs/rsh.so", local = FALSE)
+dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
+
 
 f <- function(x) {
   y <- x + 42
diff --git a/client/rsh/test5.R b/client/rsh/test5.R
index 240f90ac7..db01f342a 100644
--- a/client/rsh/test5.R
+++ b/client/rsh/test5.R
@@ -1,4 +1,4 @@
-dyn.load("../../../resources/R-4.3.2/library/rsh/libs/rsh.so", local = FALSE)
+dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
 
 f <- function (n) {
     s <- 0

From 6ffc174662db1979e0c2cf2dfc33e6bc3960b944 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 4 Sep 2024 16:25:23 +0200
Subject: [PATCH 44/80] Propagate errors in the rsh package

---
 client/rsh/Makefile                           |  2 +-
 client/rsh/NAMESPACE                          |  1 +
 client/rsh/R/rsh.R                            |  8 +++----
 client/rsh/src/client.cpp                     |  4 ++--
 client/rsh/src/client.h                       |  3 ++-
 client/rsh/src/compiler.cpp                   | 22 ++++++++++++-------
 client/rsh/src/compiler.h                     |  2 +-
 client/rsh/src/init.cpp                       |  2 +-
 .../org/prlprg/server/CompileService.java     |  2 +-
 9 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/client/rsh/Makefile b/client/rsh/Makefile
index 6ca965cef..7298c531b 100644
--- a/client/rsh/Makefile
+++ b/client/rsh/Makefile
@@ -31,4 +31,4 @@ setup:
 	$(BEAR) -- $(MAKE) clean install
 
 test:
-	LD_PRELOAD=$(LLVM_LIB) ../../external/R/bin/R -f test5.R
\ No newline at end of file
+	LD_PRELOAD=$(LLVM_LIB) ../../external/R/bin/R -f test6.R
\ No newline at end of file
diff --git a/client/rsh/NAMESPACE b/client/rsh/NAMESPACE
index e0ccb5867..4eccdd951 100644
--- a/client/rsh/NAMESPACE
+++ b/client/rsh/NAMESPACE
@@ -2,6 +2,7 @@
 
 export(rsh_cmpfun)
 export(rsh_compile)
+export(init_client)
 export(rsh_jit_disable)
 export(rsh_jit_enable)
 importFrom(compiler,cmpfun)
diff --git a/client/rsh/R/rsh.R b/client/rsh/R/rsh.R
index 567341da6..603663b68 100644
--- a/client/rsh/R/rsh.R
+++ b/client/rsh/R/rsh.R
@@ -16,10 +16,10 @@ NULL
 
 #' Initialize the Rsh client
 #' 
-#' @param IP address of the server
+#' @param address IP address of the server
 #' @param port port of the server
 #' @export
-init_client <- function(address, port) {
+init_client <- function(address="0.0.0.0", port=8980L) {
   .Call(C_init_client, address, port, installed.packages()[,1])
 }
 
@@ -43,11 +43,11 @@ rsh_jit_disable <- function() {
 #'
 #' @param f closure to be compiled
 #' @export
-rsh_compile <- function(f, name, opt_level = 0L) {
+rsh_compile <- function(f, name, opt_level = 0L, tier = "optimized") {
   if (missing(name)) {
     name <- as.character(substitute(f))
   }
-  invisible(.Call(C_compile_fun, f, name, opt_level))
+  invisible(.Call(C_compile_fun, f, name, opt_level, tier))
 }
 
 #' Compile given closure
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index c199c72a9..18adde52e 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -47,7 +47,7 @@ Client::Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string>
     }
   }
 
-protocol::CompileResponse Client::remote_compile(std::string const& name, 
+std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std::string const& name, 
                               std::vector<uint8_t> const &rds_closure,
                               protocol::Tier tier,
                               int32_t optimization_level) {
@@ -69,7 +69,7 @@ protocol::CompileResponse Client::remote_compile(std::string const& name,
   if(!status.ok()) {
     std::cerr << status.error_code() << ": " << status.error_message()
               << std::endl;
-    exit(1);//TODO: rather return an optional?
+    return status.error_message();
   }
   else {
     return response;
diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index b942ac323..f66d18c8b 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -9,6 +9,7 @@
 #include <cstdint>
 #include <string>
 #include <vector>
+#include <variant>
 #include <zmq.hpp>
 #include <grpc/grpc.h>
 #include <grpcpp/channel.h>
@@ -28,7 +29,7 @@ class Client {
 public:
   Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages);
 
-  protocol::CompileResponse remote_compile(std::string const& name, 
+  std::variant<protocol::CompileResponse, std::string> remote_compile(std::string const& name, 
                                 std::vector<uint8_t> const &rds_closure,
                                 protocol::Tier tier,
                                 int32_t optimization_level);
diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 461b16a3b..16b81fdec 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -35,11 +35,11 @@ SEXP CALL_FUN = nullptr;
 
 SEXP RSH_JIT_FUN_PTR = Rf_install("RSH_JIT_FUN_PTR");
 
-static protocol::CompileResponse compile_closure(std::string const &name, SEXP closure,
-                                       u32 opt_level = 3) {
+static std::variant<protocol::CompileResponse, std::string> compile_closure(std::string const &name, SEXP closure,
+                                       u32 opt_level = 3, protocol::Tier tier = protocol::Tier::OPTIMIZED) {
   auto closure_bytes = rsh::serialize(closure);
   auto client = rsh::Client::get_client();
-  return client->remote_compile(name, closure_bytes, protocol::Tier::OPTIMIZED, opt_level);
+  return client->remote_compile(name, closure_bytes, tier, opt_level);
 }
 
 static void *insert_into_jit(protocol::CompileResponse const &compiled_fun) {
@@ -112,7 +112,7 @@ static SEXP create_wrapper_body(SEXP closure, SEXP c_cp) {
   return body;
 }
 
-SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp) {
+SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp, SEXP tier_sxp) {
   if (!RSH_JIT_FUN_PTR) {
     Rf_error("The package was not initialized");
   }
@@ -127,16 +127,22 @@ SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp) {
 
   u32 opt_level = INTEGER(opt_level_sxp)[0];
 
+  std::string tier_s = CHAR(STRING_ELT(tier_sxp, 0));
+  protocol::Tier tier = protocol::Tier::OPTIMIZED;
+  if(tier_s == "bytecode") {
+    tier = protocol::Tier::BASELINE;
+  }
+
   const char *closure_name = CHAR(STRING_ELT(name, 0));
   char name_str[strlen(closure_name) + 1 + 16];
   sprintf(name_str, "%s_%p", closure_name, closure);
 
-  auto response = compile_closure(name_str, closure, opt_level);
-  if (false) {// TODO: propagate error from the remote compilation
-    //Rf_error("Compilation failed: %s", response.failure().c_str());
+  auto response = compile_closure(name_str, closure, opt_level, tier);
+  if (!std::holds_alternative<protocol::CompileResponse>(response)) {// TODO: propagate error from the remote compilation
+    Rf_error("Compilation failed: %s", std::get<std::string>(response).c_str());
     return closure;
   }
-  auto compiled_fun = response;
+  auto compiled_fun = std::get<protocol::CompileResponse>(response);
 
   auto fun_ptr = insert_into_jit(compiled_fun);
   SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, compiled_fun));
diff --git a/client/rsh/src/compiler.h b/client/rsh/src/compiler.h
index aeb795c0a..bf3d8d954 100644
--- a/client/rsh/src/compiler.h
+++ b/client/rsh/src/compiler.h
@@ -5,7 +5,7 @@
 namespace rsh {
 
 SEXP initialize(SEXP);
-SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level);
+SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level, SEXP tier);
 SEXP call_fun(SEXP call, SEXP op, SEXP args, SEXP env);
 
 using JitFun = SEXP (*)(SEXP env, SEXP cp);
diff --git a/client/rsh/src/init.cpp b/client/rsh/src/init.cpp
index e08599bf4..8065d3778 100644
--- a/client/rsh/src/init.cpp
+++ b/client/rsh/src/init.cpp
@@ -6,7 +6,7 @@
 extern "C" {
 static const R_CallMethodDef callMethods[] = {
     {"initialize", (DL_FUNC)&rsh::initialize, 1},
-    {"compile_fun", (DL_FUNC)&rsh::compile_fun, 3},
+    {"compile_fun", (DL_FUNC)&rsh::compile_fun, 4},
     {"init_client", (DL_FUNC)&rsh::init_client, 3},
     {NULL, NULL, 0}};
 
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 7b4fe8a6a..7a7de0b43 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -104,7 +104,7 @@ public void init(
     logger.info(
         "Received init request with R version "
             + RVersion
-            + "and Rsh version"
+            + "and Rsh version "
             + rshVersion
             + " and platform "
             + platform);

From 00dc535ba51d57f84bd679bb8cd5b5064a1e3a0b Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 4 Sep 2024 17:09:51 +0200
Subject: [PATCH 45/80] Compile to bytecode

---
 client/rsh/src/compiler.cpp | 28 ++++++++++++++++++++--------
 client/rsh/test6.R          | 18 ++++++++++++++++++
 2 files changed, 38 insertions(+), 8 deletions(-)
 create mode 100644 client/rsh/test6.R

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 16b81fdec..ce9bea02c 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -142,20 +142,32 @@ SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp, SEXP tier_sxp) {
     Rf_error("Compilation failed: %s", std::get<std::string>(response).c_str());
     return closure;
   }
+
   auto compiled_fun = std::get<protocol::CompileResponse>(response);
+  if(tier == protocol::Tier::OPTIMIZED) {
+    
 
-  auto fun_ptr = insert_into_jit(compiled_fun);
-  SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, compiled_fun));
-  SEXP body = PROTECT(create_wrapper_body(closure, c_cp));
+    auto fun_ptr = insert_into_jit(compiled_fun);
+    SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, compiled_fun));
+    SEXP body = PROTECT(create_wrapper_body(closure, c_cp));
 
-  // replace the closure body in place
-  SET_BODY(closure, body);
+    // replace the closure body in place
+    SET_BODY(closure, body);
 
-  // FIXME: add logging primitives
-  Rprintf("Compiled fun %s (fun=%p, jit=%p, body=%p)\n", name_str, closure,
+    // FIXME: add logging primitives
+    Rprintf("Compiled fun %s (fun=%p, jit=%p, body=%p)\n", name_str, closure,
           fun_ptr, body);
+    UNPROTECT(2);
 
-  UNPROTECT(2);
+  }
+  else if(tier == protocol::Tier::BASELINE) {
+    auto body = PROTECT(rsh::deserialize(compiled_fun.code()));
+    if(TYPEOF(body) != BCODESXP) {
+      Rf_error("Expected bytecode, got %s", Rf_type2char(TYPEOF(body)));
+    }
+    SET_BODY(closure, body);
+    UNPROTECT(1);
+  }
 
   return closure;
 }
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
new file mode 100644
index 000000000..f453fe8db
--- /dev/null
+++ b/client/rsh/test6.R
@@ -0,0 +1,18 @@
+dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
+
+rsh::rsh_jit_enable()
+rsh::rsh_jit_disable()
+
+f <- function(x) {
+  y <- x + 42
+  y + x
+}
+
+print(f)
+
+rsh::rsh_compile(f, tier = "bytecode")
+print(f)
+
+print(f(5))
+
+stopifnot(f(5) == 52)
\ No newline at end of file

From 9ee42e30e644d86104023b32e7db08bc6e0f245c Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 4 Sep 2024 18:06:41 +0200
Subject: [PATCH 46/80] Adding hashing

---
 client/rsh/src/client.cpp                     |    7 +-
 client/rsh/src/messages.pb.cc                 |  580 ++---
 client/rsh/src/messages.pb.h                  |  775 ++----
 client/rsh/src/xxhash.hpp                     | 2226 +++++++++++++++++
 client/rsh/test6.R                            |    2 +-
 proto/messages.proto                          |   20 +-
 .../org/prlprg/server/CompileService.java     |    8 +-
 server/src/main/proto/messages.proto          |   25 +-
 server/src/main/proto/routes.proto            |    4 +-
 9 files changed, 2741 insertions(+), 906 deletions(-)
 create mode 100644 client/rsh/src/xxhash.hpp

diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 18adde52e..394e36b15 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -1,4 +1,5 @@
 #include "client.h"
+#include "xxhash.hpp"
 
 #include <grpc/grpc.h>
 #include <grpcpp/channel.h>
@@ -59,9 +60,9 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
   request.mutable_function()->set_name(name);
   request.mutable_function()->set_body(rds_closure.data(), rds_closure.size());
 
-  // TODO: Actually compile the hash
-  std::array<uint8_t,64> hash = {0};
-  request.mutable_function()->set_hash(hash.data(), hash.size());
+  
+  auto hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
+  request.mutable_function()->set_hash(hash);
 
   grpc::ClientContext context;
   CompileResponse response;
diff --git a/client/rsh/src/messages.pb.cc b/client/rsh/src/messages.pb.cc
index d04f1c58e..620eba569 100644
--- a/client/rsh/src/messages.pb.cc
+++ b/client/rsh/src/messages.pb.cc
@@ -86,9 +86,9 @@ PROTOBUF_CONSTEXPR CompileResponse::CompileResponse(
     ::_pbi::ConstantInitialized): _impl_{
     /*decltype(_impl_._has_bits_)*/{}
   , /*decltype(_impl_._cached_size_)*/{}
-  , /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
   , /*decltype(_impl_.code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
   , /*decltype(_impl_.constants_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hash_)*/uint64_t{0u}
   , /*decltype(_impl_.tier_)*/0} {}
 struct CompileResponseDefaultTypeInternal {
   PROTOBUF_CONSTEXPR CompileResponseDefaultTypeInternal()
@@ -103,10 +103,10 @@ PROTOBUF_CONSTEXPR Function::Function(
     ::_pbi::ConstantInitialized): _impl_{
     /*decltype(_impl_._has_bits_)*/{}
   , /*decltype(_impl_._cached_size_)*/{}
-  , /*decltype(_impl_.package_hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.package_hash_)*/uint64_t{0u}
+  , /*decltype(_impl_.hash_)*/uint64_t{0u}} {}
 struct FunctionDefaultTypeInternal {
   PROTOBUF_CONSTEXPR FunctionDefaultTypeInternal()
       : _instance(::_pbi::ConstantInitialized{}) {}
@@ -118,7 +118,7 @@ struct FunctionDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FunctionDefaultTypeInternal _Function_default_instance_;
 PROTOBUF_CONSTEXPR FunctionRequest::FunctionRequest(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+    /*decltype(_impl_.hash_)*/uint64_t{0u}
   , /*decltype(_impl_._cached_size_)*/{}} {}
 struct FunctionRequestDefaultTypeInternal {
   PROTOBUF_CONSTEXPR FunctionRequestDefaultTypeInternal()
@@ -156,6 +156,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORIT
 PROTOBUF_CONSTEXPR ValueRequest::ValueRequest(
     ::_pbi::ConstantInitialized): _impl_{
     /*decltype(_impl_.hash_)*/{}
+  , /*decltype(_impl_._hash_cached_byte_size_)*/{0}
   , /*decltype(_impl_._cached_size_)*/{}} {}
 struct ValueRequestDefaultTypeInternal {
   PROTOBUF_CONSTEXPR ValueRequestDefaultTypeInternal()
@@ -168,8 +169,8 @@ struct ValueRequestDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueRequestDefaultTypeInternal _ValueRequest_default_instance_;
 PROTOBUF_CONSTEXPR Value::Value(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+    /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.hash_)*/uint64_t{0u}
   , /*decltype(_impl_._cached_size_)*/{}} {}
 struct ValueDefaultTypeInternal {
   PROTOBUF_CONSTEXPR ValueDefaultTypeInternal()
@@ -279,8 +280,8 @@ struct TestFeedbackDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TestFeedbackDefaultTypeInternal _TestFeedback_default_instance_;
 PROTOBUF_CONSTEXPR CallFeedback::CallFeedback(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.callee_hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.n_calls_)*/int64_t{0}
+    /*decltype(_impl_.n_calls_)*/int64_t{0}
+  , /*decltype(_impl_.callee_hash_)*/uint64_t{0u}
   , /*decltype(_impl_._cached_size_)*/{}} {}
 struct CallFeedbackDefaultTypeInternal {
   PROTOBUF_CONSTEXPR CallFeedbackDefaultTypeInternal()
@@ -378,6 +379,7 @@ PROTOBUF_CONSTEXPR Package::Package(
     /*decltype(_impl_._has_bits_)*/{}
   , /*decltype(_impl_._cached_size_)*/{}
   , /*decltype(_impl_.function_hashes_)*/{}
+  , /*decltype(_impl_._function_hashes_cached_byte_size_)*/{0}
   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
   , /*decltype(_impl_.version_)*/nullptr
   , /*decltype(_impl_.source_)*/nullptr} {}
@@ -392,7 +394,7 @@ struct PackageDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PackageDefaultTypeInternal _Package_default_instance_;
 PROTOBUF_CONSTEXPR PackageRequest::PackageRequest(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.hash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+    /*decltype(_impl_.hash_)*/uint64_t{0u}
   , /*decltype(_impl_._cached_size_)*/{}} {}
 struct PackageRequestDefaultTypeInternal {
   PROTOBUF_CONSTEXPR PackageRequestDefaultTypeInternal()
@@ -736,17 +738,17 @@ const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABL
   "\001(\0132\031.rsh.protocol.EnvironmentH\003\210\001\001B\007\n\005_"
   "tierB\025\n\023_optimization_levelB\n\n\010_contextB"
   "\016\n\014_environment\"\203\001\n\017CompileResponse\022\014\n\004h"
-  "ash\030\001 \001(\014\022 \n\004tier\030\002 \001(\0162\022.rsh.protocol.T"
+  "ash\030\001 \001(\004\022 \n\004tier\030\002 \001(\0162\022.rsh.protocol.T"
   "ier\022\021\n\004code\030\003 \001(\014H\000\210\001\001\022\026\n\tconstants\030\004 \001("
   "\014H\001\210\001\001B\007\n\005_codeB\014\n\n_constants\"X\n\010Functio"
-  "n\022\024\n\014package_hash\030\001 \001(\014\022\014\n\004name\030\002 \001(\t\022\014\n"
-  "\004hash\030\003 \001(\014\022\021\n\004body\030\004 \001(\014H\000\210\001\001B\007\n\005_body\""
-  "\037\n\017FunctionRequest\022\014\n\004hash\030\001 \001(\014\"s\n\013Envi"
+  "n\022\024\n\014package_hash\030\001 \001(\004\022\014\n\004name\030\002 \001(\t\022\014\n"
+  "\004hash\030\003 \001(\004\022\021\n\004body\030\004 \001(\014H\000\210\001\001B\007\n\005_body\""
+  "\037\n\017FunctionRequest\022\014\n\004hash\030\001 \001(\004\"s\n\013Envi"
   "ronment\0225\n\006values\030\001 \003(\0132%.rsh.protocol.E"
   "nvironment.ValuesEntry\032-\n\013ValuesEntry\022\013\n"
-  "\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014:\0028\001\"\034\n\014ValueRe"
-  "quest\022\014\n\004hash\030\001 \003(\014\"$\n\005Value\022\014\n\004hash\030\001 \001"
-  "(\014\022\r\n\005value\030\002 \001(\014\"-\n\006Values\022#\n\006values\030\001 "
+  "\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\004:\0028\001\"\034\n\014ValueRe"
+  "quest\022\014\n\004hash\030\001 \003(\004\"$\n\005Value\022\014\n\004hash\030\001 \001"
+  "(\004\022\r\n\005value\030\002 \001(\014\"-\n\006Values\022#\n\006values\030\001 "
   "\003(\0132\023.rsh.protocol.Value\"\007\n\005Empty\"\206\001\n\013Ca"
   "llContext\022\037\n\027args_statically_matched\030\001 \001"
   "(\010\022\036\n\026correct_number_of_args\030\002 \001(\010\022\035\n\025co"
@@ -761,7 +763,7 @@ const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABL
   "\0132\026.rsh.protocol.Function\"\?\n\014TestFeedbac"
   "k\022/\n\014test_lattice\030\001 \001(\0162\031.rsh.protocol.T"
   "estLattice\"4\n\014CallFeedback\022\017\n\007n_calls\030\001 "
-  "\001(\003\022\023\n\013callee_hash\030\002 \001(\014\"v\n\rValueFeedbac"
+  "\001(\003\022\023\n\013callee_hash\030\002 \001(\004\"v\n\rValueFeedbac"
   "k\022\016\n\006scalar\030\001 \001(\010\022\016\n\006object\030\002 \001(\010\022\033\n\023acc"
   "essed_attributes\030\003 \001(\010\022\024\n\014vectorizable\030\004"
   " \001(\010\022\022\n\nis_promise\030\005 \001(\010\"\321\002\n\014TypeFeedbac"
@@ -778,9 +780,9 @@ const char descriptor_table_protodef_messages_2eproto[] PROTOBUF_SECTION_VARIABL
   "ce\022\022\n\010r_mirror\030\002 \001(\tH\000\022\024\n\ngithub_url\030\003 \001"
   "(\tH\000B\010\n\006source\"\225\001\n\007Package\022\014\n\004name\030\001 \001(\t"
   "\022&\n\007version\030\002 \001(\0132\025.rsh.protocol.Version"
-  "\022\027\n\017function_hashes\030\004 \003(\014\0220\n\006source\030\005 \001("
+  "\022\027\n\017function_hashes\030\004 \003(\004\0220\n\006source\030\005 \001("
   "\0132\033.rsh.protocol.PackageSourceH\000\210\001\001B\t\n\007_"
-  "source\"\036\n\016PackageRequest\022\014\n\004hash\030\001 \001(\014*#"
+  "source\"\036\n\016PackageRequest\022\014\n\004hash\030\001 \001(\004*#"
   "\n\004Tier\022\014\n\010BASELINE\020\000\022\r\n\tOPTIMIZED\020\001*@\n\013T"
   "estLattice\022\010\n\004BOTH\020\000\022\r\n\tONLY_TRUE\020\001\022\016\n\nO"
   "NLY_FALSE\020\002\022\010\n\004NONE\020\003*&\n\004Type\022\007\n\003ANY\020\000\022\013"
@@ -1844,20 +1846,12 @@ CompileResponse::CompileResponse(const CompileResponse& from)
   new (&_impl_) Impl_{
       decltype(_impl_._has_bits_){from._impl_._has_bits_}
     , /*decltype(_impl_._cached_size_)*/{}
-    , decltype(_impl_.hash_){}
     , decltype(_impl_.code_){}
     , decltype(_impl_.constants_){}
+    , decltype(_impl_.hash_){}
     , decltype(_impl_.tier_){}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_hash().empty()) {
-    _this->_impl_.hash_.Set(from._internal_hash(), 
-      _this->GetArenaForAllocation());
-  }
   _impl_.code_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.code_.Set("", GetArenaForAllocation());
@@ -1874,7 +1868,9 @@ CompileResponse::CompileResponse(const CompileResponse& from)
     _this->_impl_.constants_.Set(from._internal_constants(), 
       _this->GetArenaForAllocation());
   }
-  _this->_impl_.tier_ = from._impl_.tier_;
+  ::memcpy(&_impl_.hash_, &from._impl_.hash_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.tier_) -
+    reinterpret_cast<char*>(&_impl_.hash_)) + sizeof(_impl_.tier_));
   // @@protoc_insertion_point(copy_constructor:rsh.protocol.CompileResponse)
 }
 
@@ -1885,15 +1881,11 @@ inline void CompileResponse::SharedCtor(
   new (&_impl_) Impl_{
       decltype(_impl_._has_bits_){}
     , /*decltype(_impl_._cached_size_)*/{}
-    , decltype(_impl_.hash_){}
     , decltype(_impl_.code_){}
     , decltype(_impl_.constants_){}
+    , decltype(_impl_.hash_){uint64_t{0u}}
     , decltype(_impl_.tier_){0}
   };
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.code_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.code_.Set("", GetArenaForAllocation());
@@ -1915,7 +1907,6 @@ CompileResponse::~CompileResponse() {
 
 inline void CompileResponse::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.hash_.Destroy();
   _impl_.code_.Destroy();
   _impl_.constants_.Destroy();
 }
@@ -1930,7 +1921,6 @@ void CompileResponse::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.hash_.ClearToEmpty();
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x00000003u) {
     if (cached_has_bits & 0x00000001u) {
@@ -1940,7 +1930,9 @@ void CompileResponse::Clear() {
       _impl_.constants_.ClearNonDefaultToEmpty();
     }
   }
-  _impl_.tier_ = 0;
+  ::memset(&_impl_.hash_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.tier_) -
+      reinterpret_cast<char*>(&_impl_.hash_)) + sizeof(_impl_.tier_));
   _impl_._has_bits_.Clear();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
@@ -1952,11 +1944,10 @@ const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContex
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // bytes hash = 1;
+      // uint64 hash = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          auto str = _internal_mutable_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -2018,10 +2009,10 @@ uint8_t* CompileResponse::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        1, this->_internal_hash(), target);
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_hash(), target);
   }
 
   // .rsh.protocol.Tier tier = 2;
@@ -2059,13 +2050,6 @@ size_t CompileResponse::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_hash());
-  }
-
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x00000003u) {
     // optional bytes code = 3;
@@ -2083,6 +2067,11 @@ size_t CompileResponse::ByteSizeLong() const {
     }
 
   }
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_hash());
+  }
+
   // .rsh.protocol.Tier tier = 2;
   if (this->_internal_tier() != 0) {
     total_size += 1 +
@@ -2107,9 +2096,6 @@ void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (!from._internal_hash().empty()) {
-    _this->_internal_set_hash(from._internal_hash());
-  }
   cached_has_bits = from._impl_._has_bits_[0];
   if (cached_has_bits & 0x00000003u) {
     if (cached_has_bits & 0x00000001u) {
@@ -2119,6 +2105,9 @@ void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
       _this->_internal_set_constants(from._internal_constants());
     }
   }
+  if (from._internal_hash() != 0) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
   if (from._internal_tier() != 0) {
     _this->_internal_set_tier(from._internal_tier());
   }
@@ -2142,10 +2131,6 @@ void CompileResponse::InternalSwap(CompileResponse* other) {
   auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.hash_, lhs_arena,
-      &other->_impl_.hash_, rhs_arena
-  );
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
       &_impl_.code_, lhs_arena,
       &other->_impl_.code_, rhs_arena
@@ -2154,7 +2139,12 @@ void CompileResponse::InternalSwap(CompileResponse* other) {
       &_impl_.constants_, lhs_arena,
       &other->_impl_.constants_, rhs_arena
   );
-  swap(_impl_.tier_, other->_impl_.tier_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CompileResponse, _impl_.tier_)
+      + sizeof(CompileResponse::_impl_.tier_)
+      - PROTOBUF_FIELD_OFFSET(CompileResponse, _impl_.hash_)>(
+          reinterpret_cast<char*>(&_impl_.hash_),
+          reinterpret_cast<char*>(&other->_impl_.hash_));
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata CompileResponse::GetMetadata() const {
@@ -2185,20 +2175,12 @@ Function::Function(const Function& from)
   new (&_impl_) Impl_{
       decltype(_impl_._has_bits_){from._impl_._has_bits_}
     , /*decltype(_impl_._cached_size_)*/{}
-    , decltype(_impl_.package_hash_){}
     , decltype(_impl_.name_){}
-    , decltype(_impl_.hash_){}
-    , decltype(_impl_.body_){}};
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.package_hash_){}
+    , decltype(_impl_.hash_){}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.package_hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.package_hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_package_hash().empty()) {
-    _this->_impl_.package_hash_.Set(from._internal_package_hash(), 
-      _this->GetArenaForAllocation());
-  }
   _impl_.name_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.name_.Set("", GetArenaForAllocation());
@@ -2207,14 +2189,6 @@ Function::Function(const Function& from)
     _this->_impl_.name_.Set(from._internal_name(), 
       _this->GetArenaForAllocation());
   }
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_hash().empty()) {
-    _this->_impl_.hash_.Set(from._internal_hash(), 
-      _this->GetArenaForAllocation());
-  }
   _impl_.body_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.body_.Set("", GetArenaForAllocation());
@@ -2223,6 +2197,9 @@ Function::Function(const Function& from)
     _this->_impl_.body_.Set(from._internal_body(), 
       _this->GetArenaForAllocation());
   }
+  ::memcpy(&_impl_.package_hash_, &from._impl_.package_hash_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.hash_) -
+    reinterpret_cast<char*>(&_impl_.package_hash_)) + sizeof(_impl_.hash_));
   // @@protoc_insertion_point(copy_constructor:rsh.protocol.Function)
 }
 
@@ -2233,23 +2210,15 @@ inline void Function::SharedCtor(
   new (&_impl_) Impl_{
       decltype(_impl_._has_bits_){}
     , /*decltype(_impl_._cached_size_)*/{}
-    , decltype(_impl_.package_hash_){}
     , decltype(_impl_.name_){}
-    , decltype(_impl_.hash_){}
     , decltype(_impl_.body_){}
+    , decltype(_impl_.package_hash_){uint64_t{0u}}
+    , decltype(_impl_.hash_){uint64_t{0u}}
   };
-  _impl_.package_hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.package_hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.name_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.name_.Set("", GetArenaForAllocation());
   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.body_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.body_.Set("", GetArenaForAllocation());
@@ -2267,9 +2236,7 @@ Function::~Function() {
 
 inline void Function::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.package_hash_.Destroy();
   _impl_.name_.Destroy();
-  _impl_.hash_.Destroy();
   _impl_.body_.Destroy();
 }
 
@@ -2283,13 +2250,14 @@ void Function::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.package_hash_.ClearToEmpty();
   _impl_.name_.ClearToEmpty();
-  _impl_.hash_.ClearToEmpty();
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x00000001u) {
     _impl_.body_.ClearNonDefaultToEmpty();
   }
+  ::memset(&_impl_.package_hash_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.hash_) -
+      reinterpret_cast<char*>(&_impl_.package_hash_)) + sizeof(_impl_.hash_));
   _impl_._has_bits_.Clear();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
@@ -2301,11 +2269,10 @@ const char* Function::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // bytes package_hash = 1;
+      // uint64 package_hash = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          auto str = _internal_mutable_package_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.package_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -2320,11 +2287,10 @@ const char* Function::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
         } else
           goto handle_unusual;
         continue;
-      // bytes hash = 3;
+      // uint64 hash = 3;
       case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
-          auto str = _internal_mutable_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _impl_.hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -2368,10 +2334,10 @@ uint8_t* Function::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // bytes package_hash = 1;
-  if (!this->_internal_package_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        1, this->_internal_package_hash(), target);
+  // uint64 package_hash = 1;
+  if (this->_internal_package_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_package_hash(), target);
   }
 
   // string name = 2;
@@ -2384,10 +2350,10 @@ uint8_t* Function::_InternalSerialize(
         2, this->_internal_name(), target);
   }
 
-  // bytes hash = 3;
-  if (!this->_internal_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        3, this->_internal_hash(), target);
+  // uint64 hash = 3;
+  if (this->_internal_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_hash(), target);
   }
 
   // optional bytes body = 4;
@@ -2412,13 +2378,6 @@ size_t Function::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes package_hash = 1;
-  if (!this->_internal_package_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_package_hash());
-  }
-
   // string name = 2;
   if (!this->_internal_name().empty()) {
     total_size += 1 +
@@ -2426,13 +2385,6 @@ size_t Function::ByteSizeLong() const {
         this->_internal_name());
   }
 
-  // bytes hash = 3;
-  if (!this->_internal_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_hash());
-  }
-
   // optional bytes body = 4;
   cached_has_bits = _impl_._has_bits_[0];
   if (cached_has_bits & 0x00000001u) {
@@ -2441,6 +2393,16 @@ size_t Function::ByteSizeLong() const {
         this->_internal_body());
   }
 
+  // uint64 package_hash = 1;
+  if (this->_internal_package_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_package_hash());
+  }
+
+  // uint64 hash = 3;
+  if (this->_internal_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_hash());
+  }
+
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
@@ -2459,18 +2421,18 @@ void Function::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTO
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (!from._internal_package_hash().empty()) {
-    _this->_internal_set_package_hash(from._internal_package_hash());
-  }
   if (!from._internal_name().empty()) {
     _this->_internal_set_name(from._internal_name());
   }
-  if (!from._internal_hash().empty()) {
-    _this->_internal_set_hash(from._internal_hash());
-  }
   if (from._internal_has_body()) {
     _this->_internal_set_body(from._internal_body());
   }
+  if (from._internal_package_hash() != 0) {
+    _this->_internal_set_package_hash(from._internal_package_hash());
+  }
+  if (from._internal_hash() != 0) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
@@ -2491,22 +2453,20 @@ void Function::InternalSwap(Function* other) {
   auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.package_hash_, lhs_arena,
-      &other->_impl_.package_hash_, rhs_arena
-  );
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
       &_impl_.name_, lhs_arena,
       &other->_impl_.name_, rhs_arena
   );
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.hash_, lhs_arena,
-      &other->_impl_.hash_, rhs_arena
-  );
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
       &_impl_.body_, lhs_arena,
       &other->_impl_.body_, rhs_arena
   );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Function, _impl_.hash_)
+      + sizeof(Function::_impl_.hash_)
+      - PROTOBUF_FIELD_OFFSET(Function, _impl_.package_hash_)>(
+          reinterpret_cast<char*>(&_impl_.package_hash_),
+          reinterpret_cast<char*>(&other->_impl_.package_hash_));
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata Function::GetMetadata() const {
@@ -2535,14 +2495,7 @@ FunctionRequest::FunctionRequest(const FunctionRequest& from)
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_hash().empty()) {
-    _this->_impl_.hash_.Set(from._internal_hash(), 
-      _this->GetArenaForAllocation());
-  }
+  _this->_impl_.hash_ = from._impl_.hash_;
   // @@protoc_insertion_point(copy_constructor:rsh.protocol.FunctionRequest)
 }
 
@@ -2551,13 +2504,9 @@ inline void FunctionRequest::SharedCtor(
   (void)arena;
   (void)is_message_owned;
   new (&_impl_) Impl_{
-      decltype(_impl_.hash_){}
+      decltype(_impl_.hash_){uint64_t{0u}}
     , /*decltype(_impl_._cached_size_)*/{}
   };
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
 FunctionRequest::~FunctionRequest() {
@@ -2571,7 +2520,6 @@ FunctionRequest::~FunctionRequest() {
 
 inline void FunctionRequest::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.hash_.Destroy();
 }
 
 void FunctionRequest::SetCachedSize(int size) const {
@@ -2584,7 +2532,7 @@ void FunctionRequest::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
@@ -2594,11 +2542,10 @@ const char* FunctionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContex
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // bytes hash = 1;
+      // uint64 hash = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          auto str = _internal_mutable_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -2632,10 +2579,10 @@ uint8_t* FunctionRequest::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        1, this->_internal_hash(), target);
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_hash(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -2654,11 +2601,9 @@ size_t FunctionRequest::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_hash());
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_hash());
   }
 
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
@@ -2679,7 +2624,7 @@ void FunctionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (!from._internal_hash().empty()) {
+  if (from._internal_hash() != 0) {
     _this->_internal_set_hash(from._internal_hash());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
@@ -2698,13 +2643,8 @@ bool FunctionRequest::IsInitialized() const {
 
 void FunctionRequest::InternalSwap(FunctionRequest* other) {
   using std::swap;
-  auto* lhs_arena = GetArenaForAllocation();
-  auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.hash_, lhs_arena,
-      &other->_impl_.hash_, rhs_arena
-  );
+  swap(_impl_.hash_, other->_impl_.hash_);
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata FunctionRequest::GetMetadata() const {
@@ -2804,7 +2744,7 @@ const char* Environment::_InternalParse(const char* ptr, ::_pbi::ParseContext* c
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // map<string, bytes> values = 1;
+      // map<string, uint64> values = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
           ptr -= 1;
@@ -2846,9 +2786,9 @@ uint8_t* Environment::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // map<string, bytes> values = 1;
+  // map<string, uint64> values = 1;
   if (!this->_internal_values().empty()) {
-    using MapType = ::_pb::Map<std::string, std::string>;
+    using MapType = ::_pb::Map<std::string, uint64_t>;
     using WireHelper = Environment_ValuesEntry_DoNotUse::Funcs;
     const auto& map_field = this->_internal_values();
     auto check_utf8 = [](const MapType::value_type& entry) {
@@ -2888,10 +2828,10 @@ size_t Environment::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // map<string, bytes> values = 1;
+  // map<string, uint64> values = 1;
   total_size += 1 *
       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_values_size());
-  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
+  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >::const_iterator
       it = this->_internal_values().begin();
       it != this->_internal_values().end(); ++it) {
     total_size += Environment_ValuesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
@@ -2959,6 +2899,7 @@ ValueRequest::ValueRequest(const ValueRequest& from)
   ValueRequest* const _this = this; (void)_this;
   new (&_impl_) Impl_{
       decltype(_impl_.hash_){from._impl_.hash_}
+    , /*decltype(_impl_._hash_cached_byte_size_)*/{0}
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
@@ -2971,6 +2912,7 @@ inline void ValueRequest::SharedCtor(
   (void)is_message_owned;
   new (&_impl_) Impl_{
       decltype(_impl_.hash_){arena}
+    , /*decltype(_impl_._hash_cached_byte_size_)*/{0}
     , /*decltype(_impl_._cached_size_)*/{}
   };
 }
@@ -2986,7 +2928,7 @@ ValueRequest::~ValueRequest() {
 
 inline void ValueRequest::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.hash_.~RepeatedPtrField();
+  _impl_.hash_.~RepeatedField();
 }
 
 void ValueRequest::SetCachedSize(int size) const {
@@ -3009,17 +2951,14 @@ const char* ValueRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext*
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // repeated bytes hash = 1;
+      // repeated uint64 hash = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_hash();
-            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_hash(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 8) {
+          _internal_add_hash(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
         } else
           goto handle_unusual;
         continue;
@@ -3052,10 +2991,13 @@ uint8_t* ValueRequest::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // repeated bytes hash = 1;
-  for (int i = 0, n = this->_internal_hash_size(); i < n; i++) {
-    const auto& s = this->_internal_hash(i);
-    target = stream->WriteBytes(1, s, target);
+  // repeated uint64 hash = 1;
+  {
+    int byte_size = _impl_._hash_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt64Packed(
+          1, _internal_hash(), byte_size, target);
+    }
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -3074,12 +3016,18 @@ size_t ValueRequest::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // repeated bytes hash = 1;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.hash_.size());
-  for (int i = 0, n = _impl_.hash_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-      _impl_.hash_.Get(i));
+  // repeated uint64 hash = 1;
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt64Size(this->_impl_.hash_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._hash_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
   }
 
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
@@ -3143,19 +3091,11 @@ Value::Value(const Value& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   Value* const _this = this; (void)_this;
   new (&_impl_) Impl_{
-      decltype(_impl_.hash_){}
-    , decltype(_impl_.value_){}
+      decltype(_impl_.value_){}
+    , decltype(_impl_.hash_){}
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_hash().empty()) {
-    _this->_impl_.hash_.Set(from._internal_hash(), 
-      _this->GetArenaForAllocation());
-  }
   _impl_.value_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.value_.Set("", GetArenaForAllocation());
@@ -3164,6 +3104,7 @@ Value::Value(const Value& from)
     _this->_impl_.value_.Set(from._internal_value(), 
       _this->GetArenaForAllocation());
   }
+  _this->_impl_.hash_ = from._impl_.hash_;
   // @@protoc_insertion_point(copy_constructor:rsh.protocol.Value)
 }
 
@@ -3172,14 +3113,10 @@ inline void Value::SharedCtor(
   (void)arena;
   (void)is_message_owned;
   new (&_impl_) Impl_{
-      decltype(_impl_.hash_){}
-    , decltype(_impl_.value_){}
+      decltype(_impl_.value_){}
+    , decltype(_impl_.hash_){uint64_t{0u}}
     , /*decltype(_impl_._cached_size_)*/{}
   };
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
   _impl_.value_.InitDefault();
   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
     _impl_.value_.Set("", GetArenaForAllocation());
@@ -3197,7 +3134,6 @@ Value::~Value() {
 
 inline void Value::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.hash_.Destroy();
   _impl_.value_.Destroy();
 }
 
@@ -3211,8 +3147,8 @@ void Value::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.hash_.ClearToEmpty();
   _impl_.value_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
@@ -3222,11 +3158,10 @@ const char* Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // bytes hash = 1;
+      // uint64 hash = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          auto str = _internal_mutable_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -3269,10 +3204,10 @@ uint8_t* Value::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        1, this->_internal_hash(), target);
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_hash(), target);
   }
 
   // bytes value = 2;
@@ -3297,13 +3232,6 @@ size_t Value::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_hash());
-  }
-
   // bytes value = 2;
   if (!this->_internal_value().empty()) {
     total_size += 1 +
@@ -3311,6 +3239,11 @@ size_t Value::ByteSizeLong() const {
         this->_internal_value());
   }
 
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_hash());
+  }
+
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
@@ -3329,12 +3262,12 @@ void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (!from._internal_hash().empty()) {
-    _this->_internal_set_hash(from._internal_hash());
-  }
   if (!from._internal_value().empty()) {
     _this->_internal_set_value(from._internal_value());
   }
+  if (from._internal_hash() != 0) {
+    _this->_internal_set_hash(from._internal_hash());
+  }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
@@ -3354,14 +3287,11 @@ void Value::InternalSwap(Value* other) {
   auto* lhs_arena = GetArenaForAllocation();
   auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.hash_, lhs_arena,
-      &other->_impl_.hash_, rhs_arena
-  );
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
       &_impl_.value_, lhs_arena,
       &other->_impl_.value_, rhs_arena
   );
+  swap(_impl_.hash_, other->_impl_.hash_);
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata Value::GetMetadata() const {
@@ -4745,20 +4675,14 @@ CallFeedback::CallFeedback(const CallFeedback& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
   CallFeedback* const _this = this; (void)_this;
   new (&_impl_) Impl_{
-      decltype(_impl_.callee_hash_){}
-    , decltype(_impl_.n_calls_){}
+      decltype(_impl_.n_calls_){}
+    , decltype(_impl_.callee_hash_){}
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.callee_hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.callee_hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_callee_hash().empty()) {
-    _this->_impl_.callee_hash_.Set(from._internal_callee_hash(), 
-      _this->GetArenaForAllocation());
-  }
-  _this->_impl_.n_calls_ = from._impl_.n_calls_;
+  ::memcpy(&_impl_.n_calls_, &from._impl_.n_calls_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.callee_hash_) -
+    reinterpret_cast<char*>(&_impl_.n_calls_)) + sizeof(_impl_.callee_hash_));
   // @@protoc_insertion_point(copy_constructor:rsh.protocol.CallFeedback)
 }
 
@@ -4767,14 +4691,10 @@ inline void CallFeedback::SharedCtor(
   (void)arena;
   (void)is_message_owned;
   new (&_impl_) Impl_{
-      decltype(_impl_.callee_hash_){}
-    , decltype(_impl_.n_calls_){int64_t{0}}
+      decltype(_impl_.n_calls_){int64_t{0}}
+    , decltype(_impl_.callee_hash_){uint64_t{0u}}
     , /*decltype(_impl_._cached_size_)*/{}
   };
-  _impl_.callee_hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.callee_hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
 CallFeedback::~CallFeedback() {
@@ -4788,7 +4708,6 @@ CallFeedback::~CallFeedback() {
 
 inline void CallFeedback::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.callee_hash_.Destroy();
 }
 
 void CallFeedback::SetCachedSize(int size) const {
@@ -4801,8 +4720,9 @@ void CallFeedback::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.callee_hash_.ClearToEmpty();
-  _impl_.n_calls_ = int64_t{0};
+  ::memset(&_impl_.n_calls_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&_impl_.callee_hash_) -
+      reinterpret_cast<char*>(&_impl_.n_calls_)) + sizeof(_impl_.callee_hash_));
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
@@ -4820,11 +4740,10 @@ const char* CallFeedback::_InternalParse(const char* ptr, ::_pbi::ParseContext*
         } else
           goto handle_unusual;
         continue;
-      // bytes callee_hash = 2;
+      // uint64 callee_hash = 2;
       case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
-          auto str = _internal_mutable_callee_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _impl_.callee_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -4864,10 +4783,10 @@ uint8_t* CallFeedback::_InternalSerialize(
     target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_n_calls(), target);
   }
 
-  // bytes callee_hash = 2;
-  if (!this->_internal_callee_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        2, this->_internal_callee_hash(), target);
+  // uint64 callee_hash = 2;
+  if (this->_internal_callee_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_callee_hash(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -4886,18 +4805,16 @@ size_t CallFeedback::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes callee_hash = 2;
-  if (!this->_internal_callee_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_callee_hash());
-  }
-
   // int64 n_calls = 1;
   if (this->_internal_n_calls() != 0) {
     total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_n_calls());
   }
 
+  // uint64 callee_hash = 2;
+  if (this->_internal_callee_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_callee_hash());
+  }
+
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
@@ -4916,12 +4833,12 @@ void CallFeedback::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::P
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (!from._internal_callee_hash().empty()) {
-    _this->_internal_set_callee_hash(from._internal_callee_hash());
-  }
   if (from._internal_n_calls() != 0) {
     _this->_internal_set_n_calls(from._internal_n_calls());
   }
+  if (from._internal_callee_hash() != 0) {
+    _this->_internal_set_callee_hash(from._internal_callee_hash());
+  }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
@@ -4938,14 +4855,13 @@ bool CallFeedback::IsInitialized() const {
 
 void CallFeedback::InternalSwap(CallFeedback* other) {
   using std::swap;
-  auto* lhs_arena = GetArenaForAllocation();
-  auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.callee_hash_, lhs_arena,
-      &other->_impl_.callee_hash_, rhs_arena
-  );
-  swap(_impl_.n_calls_, other->_impl_.n_calls_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(CallFeedback, _impl_.callee_hash_)
+      + sizeof(CallFeedback::_impl_.callee_hash_)
+      - PROTOBUF_FIELD_OFFSET(CallFeedback, _impl_.n_calls_)>(
+          reinterpret_cast<char*>(&_impl_.n_calls_),
+          reinterpret_cast<char*>(&other->_impl_.n_calls_));
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata CallFeedback::GetMetadata() const {
@@ -6313,6 +6229,7 @@ Package::Package(const Package& from)
       decltype(_impl_._has_bits_){from._impl_._has_bits_}
     , /*decltype(_impl_._cached_size_)*/{}
     , decltype(_impl_.function_hashes_){from._impl_.function_hashes_}
+    , /*decltype(_impl_._function_hashes_cached_byte_size_)*/{0}
     , decltype(_impl_.name_){}
     , decltype(_impl_.version_){nullptr}
     , decltype(_impl_.source_){nullptr}};
@@ -6343,6 +6260,7 @@ inline void Package::SharedCtor(
       decltype(_impl_._has_bits_){}
     , /*decltype(_impl_._cached_size_)*/{}
     , decltype(_impl_.function_hashes_){arena}
+    , /*decltype(_impl_._function_hashes_cached_byte_size_)*/{0}
     , decltype(_impl_.name_){}
     , decltype(_impl_.version_){nullptr}
     , decltype(_impl_.source_){nullptr}
@@ -6364,7 +6282,7 @@ Package::~Package() {
 
 inline void Package::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.function_hashes_.~RepeatedPtrField();
+  _impl_.function_hashes_.~RepeatedField();
   _impl_.name_.Destroy();
   if (this != internal_default_instance()) delete _impl_.version_;
   if (this != internal_default_instance()) delete _impl_.source_;
@@ -6420,17 +6338,14 @@ const char* Package::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
         } else
           goto handle_unusual;
         continue;
-      // repeated bytes function_hashes = 4;
+      // repeated uint64 function_hashes = 4;
       case 4:
         if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_function_hashes();
-            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_function_hashes(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 32) {
+          _internal_add_function_hashes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
         } else
           goto handle_unusual;
         continue;
@@ -6489,10 +6404,13 @@ uint8_t* Package::_InternalSerialize(
         _Internal::version(this).GetCachedSize(), target, stream);
   }
 
-  // repeated bytes function_hashes = 4;
-  for (int i = 0, n = this->_internal_function_hashes_size(); i < n; i++) {
-    const auto& s = this->_internal_function_hashes(i);
-    target = stream->WriteBytes(4, s, target);
+  // repeated uint64 function_hashes = 4;
+  {
+    int byte_size = _impl_._function_hashes_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt64Packed(
+          4, _internal_function_hashes(), byte_size, target);
+    }
   }
 
   // optional .rsh.protocol.PackageSource source = 5;
@@ -6518,12 +6436,18 @@ size_t Package::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // repeated bytes function_hashes = 4;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.function_hashes_.size());
-  for (int i = 0, n = _impl_.function_hashes_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-      _impl_.function_hashes_.Get(i));
+  // repeated uint64 function_hashes = 4;
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt64Size(this->_impl_.function_hashes_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._function_hashes_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
   }
 
   // string name = 1;
@@ -6637,14 +6561,7 @@ PackageRequest::PackageRequest(const PackageRequest& from)
     , /*decltype(_impl_._cached_size_)*/{}};
 
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_hash().empty()) {
-    _this->_impl_.hash_.Set(from._internal_hash(), 
-      _this->GetArenaForAllocation());
-  }
+  _this->_impl_.hash_ = from._impl_.hash_;
   // @@protoc_insertion_point(copy_constructor:rsh.protocol.PackageRequest)
 }
 
@@ -6653,13 +6570,9 @@ inline void PackageRequest::SharedCtor(
   (void)arena;
   (void)is_message_owned;
   new (&_impl_) Impl_{
-      decltype(_impl_.hash_){}
+      decltype(_impl_.hash_){uint64_t{0u}}
     , /*decltype(_impl_._cached_size_)*/{}
   };
-  _impl_.hash_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 }
 
 PackageRequest::~PackageRequest() {
@@ -6673,7 +6586,6 @@ PackageRequest::~PackageRequest() {
 
 inline void PackageRequest::SharedDtor() {
   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.hash_.Destroy();
 }
 
 void PackageRequest::SetCachedSize(int size) const {
@@ -6686,7 +6598,7 @@ void PackageRequest::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
@@ -6696,11 +6608,10 @@ const char* PackageRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext
     uint32_t tag;
     ptr = ::_pbi::ReadTag(ptr, &tag);
     switch (tag >> 3) {
-      // bytes hash = 1;
+      // uint64 hash = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          auto str = _internal_mutable_hash();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _impl_.hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
           CHK_(ptr);
         } else
           goto handle_unusual;
@@ -6734,10 +6645,10 @@ uint8_t* PackageRequest::_InternalSerialize(
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        1, this->_internal_hash(), target);
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_hash(), target);
   }
 
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -6756,11 +6667,9 @@ size_t PackageRequest::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  // bytes hash = 1;
-  if (!this->_internal_hash().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_hash());
+  // uint64 hash = 1;
+  if (this->_internal_hash() != 0) {
+    total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_hash());
   }
 
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
@@ -6781,7 +6690,7 @@ void PackageRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const :
   uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (!from._internal_hash().empty()) {
+  if (from._internal_hash() != 0) {
     _this->_internal_set_hash(from._internal_hash());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
@@ -6800,13 +6709,8 @@ bool PackageRequest::IsInitialized() const {
 
 void PackageRequest::InternalSwap(PackageRequest* other) {
   using std::swap;
-  auto* lhs_arena = GetArenaForAllocation();
-  auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.hash_, lhs_arena,
-      &other->_impl_.hash_, rhs_arena
-  );
+  swap(_impl_.hash_, other->_impl_.hash_);
 }
 
 ::PROTOBUF_NAMESPACE_ID::Metadata PackageRequest::GetMetadata() const {
diff --git a/client/rsh/src/messages.pb.h b/client/rsh/src/messages.pb.h
index 3a58a1600..51f0186c9 100644
--- a/client/rsh/src/messages.pb.h
+++ b/client/rsh/src/messages.pb.h
@@ -1102,25 +1102,11 @@ class CompileResponse final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kHashFieldNumber = 1,
     kCodeFieldNumber = 3,
     kConstantsFieldNumber = 4,
+    kHashFieldNumber = 1,
     kTierFieldNumber = 2,
   };
-  // bytes hash = 1;
-  void clear_hash();
-  const std::string& hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_hash();
-  PROTOBUF_NODISCARD std::string* release_hash();
-  void set_allocated_hash(std::string* hash);
-  private:
-  const std::string& _internal_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
-  std::string* _internal_mutable_hash();
-  public:
-
   // optional bytes code = 3;
   bool has_code() const;
   private:
@@ -1157,6 +1143,15 @@ class CompileResponse final :
   std::string* _internal_mutable_constants();
   public:
 
+  // uint64 hash = 1;
+  void clear_hash();
+  uint64_t hash() const;
+  void set_hash(uint64_t value);
+  private:
+  uint64_t _internal_hash() const;
+  void _internal_set_hash(uint64_t value);
+  public:
+
   // .rsh.protocol.Tier tier = 2;
   void clear_tier();
   ::rsh::protocol::Tier tier() const;
@@ -1176,9 +1171,9 @@ class CompileResponse final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr code_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constants_;
+    uint64_t hash_;
     int tier_;
   };
   union { Impl_ _impl_; };
@@ -1307,25 +1302,11 @@ class Function final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kPackageHashFieldNumber = 1,
     kNameFieldNumber = 2,
-    kHashFieldNumber = 3,
     kBodyFieldNumber = 4,
+    kPackageHashFieldNumber = 1,
+    kHashFieldNumber = 3,
   };
-  // bytes package_hash = 1;
-  void clear_package_hash();
-  const std::string& package_hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_package_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_package_hash();
-  PROTOBUF_NODISCARD std::string* release_package_hash();
-  void set_allocated_package_hash(std::string* package_hash);
-  private:
-  const std::string& _internal_package_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_hash(const std::string& value);
-  std::string* _internal_mutable_package_hash();
-  public:
-
   // string name = 2;
   void clear_name();
   const std::string& name() const;
@@ -1340,20 +1321,6 @@ class Function final :
   std::string* _internal_mutable_name();
   public:
 
-  // bytes hash = 3;
-  void clear_hash();
-  const std::string& hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_hash();
-  PROTOBUF_NODISCARD std::string* release_hash();
-  void set_allocated_hash(std::string* hash);
-  private:
-  const std::string& _internal_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
-  std::string* _internal_mutable_hash();
-  public:
-
   // optional bytes body = 4;
   bool has_body() const;
   private:
@@ -1372,6 +1339,24 @@ class Function final :
   std::string* _internal_mutable_body();
   public:
 
+  // uint64 package_hash = 1;
+  void clear_package_hash();
+  uint64_t package_hash() const;
+  void set_package_hash(uint64_t value);
+  private:
+  uint64_t _internal_package_hash() const;
+  void _internal_set_package_hash(uint64_t value);
+  public:
+
+  // uint64 hash = 3;
+  void clear_hash();
+  uint64_t hash() const;
+  void set_hash(uint64_t value);
+  private:
+  uint64_t _internal_hash() const;
+  void _internal_set_hash(uint64_t value);
+  public:
+
   // @@protoc_insertion_point(class_scope:rsh.protocol.Function)
  private:
   class _Internal;
@@ -1382,10 +1367,10 @@ class Function final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_hash_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+    uint64_t package_hash_;
+    uint64_t hash_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2eproto;
@@ -1515,18 +1500,13 @@ class FunctionRequest final :
   enum : int {
     kHashFieldNumber = 1,
   };
-  // bytes hash = 1;
+  // uint64 hash = 1;
   void clear_hash();
-  const std::string& hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_hash();
-  PROTOBUF_NODISCARD std::string* release_hash();
-  void set_allocated_hash(std::string* hash);
+  uint64_t hash() const;
+  void set_hash(uint64_t value);
   private:
-  const std::string& _internal_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
-  std::string* _internal_mutable_hash();
+  uint64_t _internal_hash() const;
+  void _internal_set_hash(uint64_t value);
   public:
 
   // @@protoc_insertion_point(class_scope:rsh.protocol.FunctionRequest)
@@ -1537,7 +1517,7 @@ class FunctionRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    uint64_t hash_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -1546,14 +1526,14 @@ class FunctionRequest final :
 // -------------------------------------------------------------------
 
 class Environment_ValuesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Environment_ValuesEntry_DoNotUse, 
-    std::string, std::string,
+    std::string, uint64_t,
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> {
 public:
   typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Environment_ValuesEntry_DoNotUse, 
-    std::string, std::string,
+    std::string, uint64_t,
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> SuperType;
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> SuperType;
   Environment_ValuesEntry_DoNotUse();
   explicit PROTOBUF_CONSTEXPR Environment_ValuesEntry_DoNotUse(
       ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
@@ -1697,21 +1677,21 @@ class Environment final :
   enum : int {
     kValuesFieldNumber = 1,
   };
-  // map<string, bytes> values = 1;
+  // map<string, uint64> values = 1;
   int values_size() const;
   private:
   int _internal_values_size() const;
   public:
   void clear_values();
   private:
-  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
       _internal_values() const;
-  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
       _internal_mutable_values();
   public:
-  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
       values() const;
-  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
       mutable_values();
 
   // @@protoc_insertion_point(class_scope:rsh.protocol.Environment)
@@ -1724,9 +1704,9 @@ class Environment final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::internal::MapField<
         Environment_ValuesEntry_DoNotUse,
-        std::string, std::string,
+        std::string, uint64_t,
         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BYTES> values_;
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64> values_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -1857,29 +1837,27 @@ class ValueRequest final :
   enum : int {
     kHashFieldNumber = 1,
   };
-  // repeated bytes hash = 1;
+  // repeated uint64 hash = 1;
   int hash_size() const;
   private:
   int _internal_hash_size() const;
   public:
   void clear_hash();
-  const std::string& hash(int index) const;
-  std::string* mutable_hash(int index);
-  void set_hash(int index, const std::string& value);
-  void set_hash(int index, std::string&& value);
-  void set_hash(int index, const char* value);
-  void set_hash(int index, const void* value, size_t size);
-  std::string* add_hash();
-  void add_hash(const std::string& value);
-  void add_hash(std::string&& value);
-  void add_hash(const char* value);
-  void add_hash(const void* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& hash() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_hash();
-  private:
-  const std::string& _internal_hash(int index) const;
-  std::string* _internal_add_hash();
-  public:
+  private:
+  uint64_t _internal_hash(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_hash() const;
+  void _internal_add_hash(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_hash();
+  public:
+  uint64_t hash(int index) const;
+  void set_hash(int index, uint64_t value);
+  void add_hash(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      hash() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_hash();
 
   // @@protoc_insertion_point(class_scope:rsh.protocol.ValueRequest)
  private:
@@ -1889,7 +1867,8 @@ class ValueRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> hash_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > hash_;
+    mutable std::atomic<int> _hash_cached_byte_size_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -2018,23 +1997,9 @@ class Value final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kHashFieldNumber = 1,
     kValueFieldNumber = 2,
+    kHashFieldNumber = 1,
   };
-  // bytes hash = 1;
-  void clear_hash();
-  const std::string& hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_hash();
-  PROTOBUF_NODISCARD std::string* release_hash();
-  void set_allocated_hash(std::string* hash);
-  private:
-  const std::string& _internal_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
-  std::string* _internal_mutable_hash();
-  public:
-
   // bytes value = 2;
   void clear_value();
   const std::string& value() const;
@@ -2049,6 +2014,15 @@ class Value final :
   std::string* _internal_mutable_value();
   public:
 
+  // uint64 hash = 1;
+  void clear_hash();
+  uint64_t hash() const;
+  void set_hash(uint64_t value);
+  private:
+  uint64_t _internal_hash() const;
+  void _internal_set_hash(uint64_t value);
+  public:
+
   // @@protoc_insertion_point(class_scope:rsh.protocol.Value)
  private:
   class _Internal;
@@ -2057,8 +2031,8 @@ class Value final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+    uint64_t hash_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -3311,23 +3285,9 @@ class CallFeedback final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kCalleeHashFieldNumber = 2,
     kNCallsFieldNumber = 1,
+    kCalleeHashFieldNumber = 2,
   };
-  // bytes callee_hash = 2;
-  void clear_callee_hash();
-  const std::string& callee_hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_callee_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_callee_hash();
-  PROTOBUF_NODISCARD std::string* release_callee_hash();
-  void set_allocated_callee_hash(std::string* callee_hash);
-  private:
-  const std::string& _internal_callee_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callee_hash(const std::string& value);
-  std::string* _internal_mutable_callee_hash();
-  public:
-
   // int64 n_calls = 1;
   void clear_n_calls();
   int64_t n_calls() const;
@@ -3337,6 +3297,15 @@ class CallFeedback final :
   void _internal_set_n_calls(int64_t value);
   public:
 
+  // uint64 callee_hash = 2;
+  void clear_callee_hash();
+  uint64_t callee_hash() const;
+  void set_callee_hash(uint64_t value);
+  private:
+  uint64_t _internal_callee_hash() const;
+  void _internal_set_callee_hash(uint64_t value);
+  public:
+
   // @@protoc_insertion_point(class_scope:rsh.protocol.CallFeedback)
  private:
   class _Internal;
@@ -3345,8 +3314,8 @@ class CallFeedback final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callee_hash_;
     int64_t n_calls_;
+    uint64_t callee_hash_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -4431,29 +4400,27 @@ class Package final :
     kVersionFieldNumber = 2,
     kSourceFieldNumber = 5,
   };
-  // repeated bytes function_hashes = 4;
+  // repeated uint64 function_hashes = 4;
   int function_hashes_size() const;
   private:
   int _internal_function_hashes_size() const;
   public:
   void clear_function_hashes();
-  const std::string& function_hashes(int index) const;
-  std::string* mutable_function_hashes(int index);
-  void set_function_hashes(int index, const std::string& value);
-  void set_function_hashes(int index, std::string&& value);
-  void set_function_hashes(int index, const char* value);
-  void set_function_hashes(int index, const void* value, size_t size);
-  std::string* add_function_hashes();
-  void add_function_hashes(const std::string& value);
-  void add_function_hashes(std::string&& value);
-  void add_function_hashes(const char* value);
-  void add_function_hashes(const void* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& function_hashes() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_function_hashes();
-  private:
-  const std::string& _internal_function_hashes(int index) const;
-  std::string* _internal_add_function_hashes();
-  public:
+  private:
+  uint64_t _internal_function_hashes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_function_hashes() const;
+  void _internal_add_function_hashes(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_function_hashes();
+  public:
+  uint64_t function_hashes(int index) const;
+  void set_function_hashes(int index, uint64_t value);
+  void add_function_hashes(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      function_hashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_function_hashes();
 
   // string name = 1;
   void clear_name();
@@ -4515,7 +4482,8 @@ class Package final :
   struct Impl_ {
     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> function_hashes_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > function_hashes_;
+    mutable std::atomic<int> _function_hashes_cached_byte_size_;
     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
     ::rsh::protocol::Version* version_;
     ::rsh::protocol::PackageSource* source_;
@@ -4648,18 +4616,13 @@ class PackageRequest final :
   enum : int {
     kHashFieldNumber = 1,
   };
-  // bytes hash = 1;
+  // uint64 hash = 1;
   void clear_hash();
-  const std::string& hash() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_hash(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_hash();
-  PROTOBUF_NODISCARD std::string* release_hash();
-  void set_allocated_hash(std::string* hash);
+  uint64_t hash() const;
+  void set_hash(uint64_t value);
   private:
-  const std::string& _internal_hash() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hash(const std::string& value);
-  std::string* _internal_mutable_hash();
+  uint64_t _internal_hash() const;
+  void _internal_set_hash(uint64_t value);
   public:
 
   // @@protoc_insertion_point(class_scope:rsh.protocol.PackageRequest)
@@ -4670,7 +4633,7 @@ class PackageRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
+    uint64_t hash_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -5394,54 +5357,24 @@ inline void CompileRequest::set_allocated_environment(::rsh::protocol::Environme
 
 // CompileResponse
 
-// bytes hash = 1;
+// uint64 hash = 1;
 inline void CompileResponse::clear_hash() {
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
+}
+inline uint64_t CompileResponse::_internal_hash() const {
+  return _impl_.hash_;
 }
-inline const std::string& CompileResponse::hash() const {
+inline uint64_t CompileResponse::hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.CompileResponse.hash)
   return _internal_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CompileResponse::set_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.hash)
-}
-inline std::string* CompileResponse::mutable_hash() {
-  std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.CompileResponse.hash)
-  return _s;
-}
-inline const std::string& CompileResponse::_internal_hash() const {
-  return _impl_.hash_.Get();
-}
-inline void CompileResponse::_internal_set_hash(const std::string& value) {
-  
-  _impl_.hash_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompileResponse::_internal_mutable_hash() {
+inline void CompileResponse::_internal_set_hash(uint64_t value) {
   
-  return _impl_.hash_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CompileResponse::release_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.CompileResponse.hash)
-  return _impl_.hash_.Release();
+  _impl_.hash_ = value;
 }
-inline void CompileResponse::set_allocated_hash(std::string* hash) {
-  if (hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.hash_.IsDefault()) {
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CompileResponse.hash)
+inline void CompileResponse::set_hash(uint64_t value) {
+  _internal_set_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.CompileResponse.hash)
 }
 
 // .rsh.protocol.Tier tier = 2;
@@ -5604,54 +5537,24 @@ inline void CompileResponse::set_allocated_constants(std::string* constants) {
 
 // Function
 
-// bytes package_hash = 1;
+// uint64 package_hash = 1;
 inline void Function::clear_package_hash() {
-  _impl_.package_hash_.ClearToEmpty();
+  _impl_.package_hash_ = uint64_t{0u};
 }
-inline const std::string& Function::package_hash() const {
+inline uint64_t Function::_internal_package_hash() const {
+  return _impl_.package_hash_;
+}
+inline uint64_t Function::package_hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.Function.package_hash)
   return _internal_package_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Function::set_package_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.package_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.Function.package_hash)
-}
-inline std::string* Function::mutable_package_hash() {
-  std::string* _s = _internal_mutable_package_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.Function.package_hash)
-  return _s;
-}
-inline const std::string& Function::_internal_package_hash() const {
-  return _impl_.package_hash_.Get();
-}
-inline void Function::_internal_set_package_hash(const std::string& value) {
-  
-  _impl_.package_hash_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Function::_internal_mutable_package_hash() {
+inline void Function::_internal_set_package_hash(uint64_t value) {
   
-  return _impl_.package_hash_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Function::release_package_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.Function.package_hash)
-  return _impl_.package_hash_.Release();
+  _impl_.package_hash_ = value;
 }
-inline void Function::set_allocated_package_hash(std::string* package_hash) {
-  if (package_hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.package_hash_.SetAllocated(package_hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.package_hash_.IsDefault()) {
-    _impl_.package_hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.package_hash)
+inline void Function::set_package_hash(uint64_t value) {
+  _internal_set_package_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.Function.package_hash)
 }
 
 // string name = 2;
@@ -5704,54 +5607,24 @@ inline void Function::set_allocated_name(std::string* name) {
   // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.name)
 }
 
-// bytes hash = 3;
+// uint64 hash = 3;
 inline void Function::clear_hash() {
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
+}
+inline uint64_t Function::_internal_hash() const {
+  return _impl_.hash_;
 }
-inline const std::string& Function::hash() const {
+inline uint64_t Function::hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.Function.hash)
   return _internal_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Function::set_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.Function.hash)
-}
-inline std::string* Function::mutable_hash() {
-  std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.Function.hash)
-  return _s;
-}
-inline const std::string& Function::_internal_hash() const {
-  return _impl_.hash_.Get();
-}
-inline void Function::_internal_set_hash(const std::string& value) {
+inline void Function::_internal_set_hash(uint64_t value) {
   
-  _impl_.hash_.Set(value, GetArenaForAllocation());
+  _impl_.hash_ = value;
 }
-inline std::string* Function::_internal_mutable_hash() {
-  
-  return _impl_.hash_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Function::release_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.Function.hash)
-  return _impl_.hash_.Release();
-}
-inline void Function::set_allocated_hash(std::string* hash) {
-  if (hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.hash_.IsDefault()) {
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Function.hash)
+inline void Function::set_hash(uint64_t value) {
+  _internal_set_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.Function.hash)
 }
 
 // optional bytes body = 4;
@@ -5826,54 +5699,24 @@ inline void Function::set_allocated_body(std::string* body) {
 
 // FunctionRequest
 
-// bytes hash = 1;
+// uint64 hash = 1;
 inline void FunctionRequest::clear_hash() {
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
 }
-inline const std::string& FunctionRequest::hash() const {
+inline uint64_t FunctionRequest::_internal_hash() const {
+  return _impl_.hash_;
+}
+inline uint64_t FunctionRequest::hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.FunctionRequest.hash)
   return _internal_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FunctionRequest::set_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.FunctionRequest.hash)
-}
-inline std::string* FunctionRequest::mutable_hash() {
-  std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.FunctionRequest.hash)
-  return _s;
-}
-inline const std::string& FunctionRequest::_internal_hash() const {
-  return _impl_.hash_.Get();
-}
-inline void FunctionRequest::_internal_set_hash(const std::string& value) {
-  
-  _impl_.hash_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FunctionRequest::_internal_mutable_hash() {
+inline void FunctionRequest::_internal_set_hash(uint64_t value) {
   
-  return _impl_.hash_.Mutable(GetArenaForAllocation());
+  _impl_.hash_ = value;
 }
-inline std::string* FunctionRequest::release_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.FunctionRequest.hash)
-  return _impl_.hash_.Release();
-}
-inline void FunctionRequest::set_allocated_hash(std::string* hash) {
-  if (hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.hash_.IsDefault()) {
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.FunctionRequest.hash)
+inline void FunctionRequest::set_hash(uint64_t value) {
+  _internal_set_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.FunctionRequest.hash)
 }
 
 // -------------------------------------------------------------------
@@ -5882,7 +5725,7 @@ inline void FunctionRequest::set_allocated_hash(std::string* hash) {
 
 // Environment
 
-// map<string, bytes> values = 1;
+// map<string, uint64> values = 1;
 inline int Environment::_internal_values_size() const {
   return _impl_.values_.size();
 }
@@ -5892,20 +5735,20 @@ inline int Environment::values_size() const {
 inline void Environment::clear_values() {
   _impl_.values_.Clear();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
 Environment::_internal_values() const {
   return _impl_.values_.GetMap();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
 Environment::values() const {
   // @@protoc_insertion_point(field_map:rsh.protocol.Environment.values)
   return _internal_values();
 }
-inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
 Environment::_internal_mutable_values() {
   return _impl_.values_.MutableMap();
 }
-inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
 Environment::mutable_values() {
   // @@protoc_insertion_point(field_mutable_map:rsh.protocol.Environment.values)
   return _internal_mutable_values();
@@ -5915,7 +5758,7 @@ Environment::mutable_values() {
 
 // ValueRequest
 
-// repeated bytes hash = 1;
+// repeated uint64 hash = 1;
 inline int ValueRequest::_internal_hash_size() const {
   return _impl_.hash_.size();
 }
@@ -5925,123 +5768,65 @@ inline int ValueRequest::hash_size() const {
 inline void ValueRequest::clear_hash() {
   _impl_.hash_.Clear();
 }
-inline std::string* ValueRequest::add_hash() {
-  std::string* _s = _internal_add_hash();
-  // @@protoc_insertion_point(field_add_mutable:rsh.protocol.ValueRequest.hash)
-  return _s;
-}
-inline const std::string& ValueRequest::_internal_hash(int index) const {
+inline uint64_t ValueRequest::_internal_hash(int index) const {
   return _impl_.hash_.Get(index);
 }
-inline const std::string& ValueRequest::hash(int index) const {
+inline uint64_t ValueRequest::hash(int index) const {
   // @@protoc_insertion_point(field_get:rsh.protocol.ValueRequest.hash)
   return _internal_hash(index);
 }
-inline std::string* ValueRequest::mutable_hash(int index) {
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.ValueRequest.hash)
-  return _impl_.hash_.Mutable(index);
-}
-inline void ValueRequest::set_hash(int index, const std::string& value) {
-  _impl_.hash_.Mutable(index)->assign(value);
+inline void ValueRequest::set_hash(int index, uint64_t value) {
+  _impl_.hash_.Set(index, value);
   // @@protoc_insertion_point(field_set:rsh.protocol.ValueRequest.hash)
 }
-inline void ValueRequest::set_hash(int index, std::string&& value) {
-  _impl_.hash_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:rsh.protocol.ValueRequest.hash)
-}
-inline void ValueRequest::set_hash(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.hash_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:rsh.protocol.ValueRequest.hash)
-}
-inline void ValueRequest::set_hash(int index, const void* value, size_t size) {
-  _impl_.hash_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:rsh.protocol.ValueRequest.hash)
-}
-inline std::string* ValueRequest::_internal_add_hash() {
-  return _impl_.hash_.Add();
-}
-inline void ValueRequest::add_hash(const std::string& value) {
-  _impl_.hash_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:rsh.protocol.ValueRequest.hash)
+inline void ValueRequest::_internal_add_hash(uint64_t value) {
+  _impl_.hash_.Add(value);
 }
-inline void ValueRequest::add_hash(std::string&& value) {
-  _impl_.hash_.Add(std::move(value));
+inline void ValueRequest::add_hash(uint64_t value) {
+  _internal_add_hash(value);
   // @@protoc_insertion_point(field_add:rsh.protocol.ValueRequest.hash)
 }
-inline void ValueRequest::add_hash(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.hash_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:rsh.protocol.ValueRequest.hash)
-}
-inline void ValueRequest::add_hash(const void* value, size_t size) {
-  _impl_.hash_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:rsh.protocol.ValueRequest.hash)
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ValueRequest::_internal_hash() const {
+  return _impl_.hash_;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
 ValueRequest::hash() const {
   // @@protoc_insertion_point(field_list:rsh.protocol.ValueRequest.hash)
-  return _impl_.hash_;
+  return _internal_hash();
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ValueRequest::_internal_mutable_hash() {
+  return &_impl_.hash_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
 ValueRequest::mutable_hash() {
   // @@protoc_insertion_point(field_mutable_list:rsh.protocol.ValueRequest.hash)
-  return &_impl_.hash_;
+  return _internal_mutable_hash();
 }
 
 // -------------------------------------------------------------------
 
 // Value
 
-// bytes hash = 1;
+// uint64 hash = 1;
 inline void Value::clear_hash() {
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
+}
+inline uint64_t Value::_internal_hash() const {
+  return _impl_.hash_;
 }
-inline const std::string& Value::hash() const {
+inline uint64_t Value::hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.Value.hash)
   return _internal_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Value::set_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.Value.hash)
-}
-inline std::string* Value::mutable_hash() {
-  std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.Value.hash)
-  return _s;
-}
-inline const std::string& Value::_internal_hash() const {
-  return _impl_.hash_.Get();
-}
-inline void Value::_internal_set_hash(const std::string& value) {
-  
-  _impl_.hash_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Value::_internal_mutable_hash() {
+inline void Value::_internal_set_hash(uint64_t value) {
   
-  return _impl_.hash_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Value::release_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.Value.hash)
-  return _impl_.hash_.Release();
+  _impl_.hash_ = value;
 }
-inline void Value::set_allocated_hash(std::string* hash) {
-  if (hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.hash_.IsDefault()) {
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Value.hash)
+inline void Value::set_hash(uint64_t value) {
+  _internal_set_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.Value.hash)
 }
 
 // bytes value = 2;
@@ -6594,54 +6379,24 @@ inline void CallFeedback::set_n_calls(int64_t value) {
   // @@protoc_insertion_point(field_set:rsh.protocol.CallFeedback.n_calls)
 }
 
-// bytes callee_hash = 2;
+// uint64 callee_hash = 2;
 inline void CallFeedback::clear_callee_hash() {
-  _impl_.callee_hash_.ClearToEmpty();
+  _impl_.callee_hash_ = uint64_t{0u};
+}
+inline uint64_t CallFeedback::_internal_callee_hash() const {
+  return _impl_.callee_hash_;
 }
-inline const std::string& CallFeedback::callee_hash() const {
+inline uint64_t CallFeedback::callee_hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.CallFeedback.callee_hash)
   return _internal_callee_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CallFeedback::set_callee_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.callee_hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.CallFeedback.callee_hash)
-}
-inline std::string* CallFeedback::mutable_callee_hash() {
-  std::string* _s = _internal_mutable_callee_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.CallFeedback.callee_hash)
-  return _s;
-}
-inline const std::string& CallFeedback::_internal_callee_hash() const {
-  return _impl_.callee_hash_.Get();
-}
-inline void CallFeedback::_internal_set_callee_hash(const std::string& value) {
-  
-  _impl_.callee_hash_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CallFeedback::_internal_mutable_callee_hash() {
+inline void CallFeedback::_internal_set_callee_hash(uint64_t value) {
   
-  return _impl_.callee_hash_.Mutable(GetArenaForAllocation());
+  _impl_.callee_hash_ = value;
 }
-inline std::string* CallFeedback::release_callee_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.CallFeedback.callee_hash)
-  return _impl_.callee_hash_.Release();
-}
-inline void CallFeedback::set_allocated_callee_hash(std::string* callee_hash) {
-  if (callee_hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.callee_hash_.SetAllocated(callee_hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.callee_hash_.IsDefault()) {
-    _impl_.callee_hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.CallFeedback.callee_hash)
+inline void CallFeedback::set_callee_hash(uint64_t value) {
+  _internal_set_callee_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.CallFeedback.callee_hash)
 }
 
 // -------------------------------------------------------------------
@@ -7423,7 +7178,7 @@ inline void Package::set_allocated_version(::rsh::protocol::Version* version) {
   // @@protoc_insertion_point(field_set_allocated:rsh.protocol.Package.version)
 }
 
-// repeated bytes function_hashes = 4;
+// repeated uint64 function_hashes = 4;
 inline int Package::_internal_function_hashes_size() const {
   return _impl_.function_hashes_.size();
 }
@@ -7433,69 +7188,41 @@ inline int Package::function_hashes_size() const {
 inline void Package::clear_function_hashes() {
   _impl_.function_hashes_.Clear();
 }
-inline std::string* Package::add_function_hashes() {
-  std::string* _s = _internal_add_function_hashes();
-  // @@protoc_insertion_point(field_add_mutable:rsh.protocol.Package.function_hashes)
-  return _s;
-}
-inline const std::string& Package::_internal_function_hashes(int index) const {
+inline uint64_t Package::_internal_function_hashes(int index) const {
   return _impl_.function_hashes_.Get(index);
 }
-inline const std::string& Package::function_hashes(int index) const {
+inline uint64_t Package::function_hashes(int index) const {
   // @@protoc_insertion_point(field_get:rsh.protocol.Package.function_hashes)
   return _internal_function_hashes(index);
 }
-inline std::string* Package::mutable_function_hashes(int index) {
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.Package.function_hashes)
-  return _impl_.function_hashes_.Mutable(index);
-}
-inline void Package::set_function_hashes(int index, const std::string& value) {
-  _impl_.function_hashes_.Mutable(index)->assign(value);
+inline void Package::set_function_hashes(int index, uint64_t value) {
+  _impl_.function_hashes_.Set(index, value);
   // @@protoc_insertion_point(field_set:rsh.protocol.Package.function_hashes)
 }
-inline void Package::set_function_hashes(int index, std::string&& value) {
-  _impl_.function_hashes_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:rsh.protocol.Package.function_hashes)
-}
-inline void Package::set_function_hashes(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.function_hashes_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:rsh.protocol.Package.function_hashes)
-}
-inline void Package::set_function_hashes(int index, const void* value, size_t size) {
-  _impl_.function_hashes_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:rsh.protocol.Package.function_hashes)
-}
-inline std::string* Package::_internal_add_function_hashes() {
-  return _impl_.function_hashes_.Add();
-}
-inline void Package::add_function_hashes(const std::string& value) {
-  _impl_.function_hashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:rsh.protocol.Package.function_hashes)
+inline void Package::_internal_add_function_hashes(uint64_t value) {
+  _impl_.function_hashes_.Add(value);
 }
-inline void Package::add_function_hashes(std::string&& value) {
-  _impl_.function_hashes_.Add(std::move(value));
+inline void Package::add_function_hashes(uint64_t value) {
+  _internal_add_function_hashes(value);
   // @@protoc_insertion_point(field_add:rsh.protocol.Package.function_hashes)
 }
-inline void Package::add_function_hashes(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.function_hashes_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:rsh.protocol.Package.function_hashes)
-}
-inline void Package::add_function_hashes(const void* value, size_t size) {
-  _impl_.function_hashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:rsh.protocol.Package.function_hashes)
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+Package::_internal_function_hashes() const {
+  return _impl_.function_hashes_;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
 Package::function_hashes() const {
   // @@protoc_insertion_point(field_list:rsh.protocol.Package.function_hashes)
-  return _impl_.function_hashes_;
+  return _internal_function_hashes();
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+Package::_internal_mutable_function_hashes() {
+  return &_impl_.function_hashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
 Package::mutable_function_hashes() {
   // @@protoc_insertion_point(field_mutable_list:rsh.protocol.Package.function_hashes)
-  return &_impl_.function_hashes_;
+  return _internal_mutable_function_hashes();
 }
 
 // optional .rsh.protocol.PackageSource source = 5;
@@ -7592,54 +7319,24 @@ inline void Package::set_allocated_source(::rsh::protocol::PackageSource* source
 
 // PackageRequest
 
-// bytes hash = 1;
+// uint64 hash = 1;
 inline void PackageRequest::clear_hash() {
-  _impl_.hash_.ClearToEmpty();
+  _impl_.hash_ = uint64_t{0u};
+}
+inline uint64_t PackageRequest::_internal_hash() const {
+  return _impl_.hash_;
 }
-inline const std::string& PackageRequest::hash() const {
+inline uint64_t PackageRequest::hash() const {
   // @@protoc_insertion_point(field_get:rsh.protocol.PackageRequest.hash)
   return _internal_hash();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void PackageRequest::set_hash(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.hash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.protocol.PackageRequest.hash)
-}
-inline std::string* PackageRequest::mutable_hash() {
-  std::string* _s = _internal_mutable_hash();
-  // @@protoc_insertion_point(field_mutable:rsh.protocol.PackageRequest.hash)
-  return _s;
-}
-inline const std::string& PackageRequest::_internal_hash() const {
-  return _impl_.hash_.Get();
-}
-inline void PackageRequest::_internal_set_hash(const std::string& value) {
+inline void PackageRequest::_internal_set_hash(uint64_t value) {
   
-  _impl_.hash_.Set(value, GetArenaForAllocation());
+  _impl_.hash_ = value;
 }
-inline std::string* PackageRequest::_internal_mutable_hash() {
-  
-  return _impl_.hash_.Mutable(GetArenaForAllocation());
-}
-inline std::string* PackageRequest::release_hash() {
-  // @@protoc_insertion_point(field_release:rsh.protocol.PackageRequest.hash)
-  return _impl_.hash_.Release();
-}
-inline void PackageRequest::set_allocated_hash(std::string* hash) {
-  if (hash != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.hash_.SetAllocated(hash, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.hash_.IsDefault()) {
-    _impl_.hash_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.protocol.PackageRequest.hash)
+inline void PackageRequest::set_hash(uint64_t value) {
+  _internal_set_hash(value);
+  // @@protoc_insertion_point(field_set:rsh.protocol.PackageRequest.hash)
 }
 
 #ifdef __GNUC__
diff --git a/client/rsh/src/xxhash.hpp b/client/rsh/src/xxhash.hpp
new file mode 100644
index 000000000..886454841
--- /dev/null
+++ b/client/rsh/src/xxhash.hpp
@@ -0,0 +1,2226 @@
+#pragma once
+#include <cstdint>
+#include <cstring>
+#include <array>
+#include <type_traits>
+#include <vector>
+#include <string>
+
+/*
+xxHash - Extremely Fast Hash algorithm
+Header File
+Copyright (C) 2012-2024, Yann Collet.
+Copyright (C) 2017-2024, Red Gavin.
+All rights reserved.
+
+BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+You can contact the author at :
+- xxHash source repository : https://github.com/Cyan4973/xxHash
+- xxHash C++ port repository : https://github.com/RedSpah/xxhash_cpp
+*/
+
+/* Intrinsics
+* Sadly has to be included in the global namespace or literally everything breaks
+*/
+#if (defined(__ARM_NEON) && defined(__APPLE__))
+#include "sse2neon.h"
+#else
+#include <immintrin.h>
+#endif
+
+namespace xxh
+{
+	/* *************************************
+	*  Versioning
+	***************************************/
+
+	namespace version
+	{
+		constexpr int cpp_version_major = 0;
+		constexpr int cpp_version_minor = 8;
+		constexpr int cpp_version_release = 1;
+	}
+
+	constexpr uint32_t version_number() 
+	{ 
+		return version::cpp_version_major * 10000 + version::cpp_version_minor * 100 + version::cpp_version_release;
+	}
+
+
+	/* *************************************
+	*  Basic Types - Predefining uint128_t for intrin
+	***************************************/
+
+	namespace typedefs
+	{
+		struct alignas(16) uint128_t
+		{
+			uint64_t low64 = 0;
+			uint64_t high64 = 0;
+
+			bool operator==(const uint128_t & other)
+			{
+				return (low64 == other.low64 && high64 == other.high64);
+			}
+
+			bool operator>(const uint128_t & other)
+			{
+				return (high64 > other.high64 || low64 > other.low64);
+			}
+
+			bool operator>=(const uint128_t & other)
+			{
+				return (*this > other || *this == other);
+			}
+
+			bool operator<(const uint128_t & other)
+			{
+				return !(*this >= other);
+			}
+
+			bool operator<=(const uint128_t & other)
+			{
+				return !(*this > other);
+			}
+
+			bool operator!=(const uint128_t & other)
+			{
+				return !(*this == other);
+			}
+
+			uint128_t(uint64_t low, uint64_t high) : low64(low), high64(high) {}
+
+			uint128_t() {}
+		};
+
+	}
+
+	using uint128_t = typedefs::uint128_t;
+
+
+	/* *************************************
+	*  Compiler / Platform Specific Features
+	***************************************/
+
+	namespace intrin
+	{
+		/*!XXH_CPU_LITTLE_ENDIAN :
+		* This is a CPU endian detection macro, will be
+		* automatically set to 1 (little endian) if it is left undefined.
+		* If compiling for a big endian system (why), XXH_CPU_LITTLE_ENDIAN has to be explicitly defined as 0.
+		*/
+#ifndef XXH_CPU_LITTLE_ENDIAN
+#	define XXH_CPU_LITTLE_ENDIAN 1
+#endif
+
+
+		/* Vectorization Detection
+		* NOTE: XXH_NEON and XXH_VSX aren't supported in this C++ port.
+		* The primary reason is that I don't have access to an ARM and PowerPC
+		* machines to test them, and the secondary reason is that I even doubt anyone writing
+		* code for such machines would bother using a C++ port rather than the original C version.
+		*/
+#ifndef XXH_VECTOR   /* can be predefined on command line */
+#	if defined(__AVX512F__) 
+#		define XXH_VECTOR 3 /* AVX512 for Skylake and Icelake */
+#	elif defined(__AVX2__)
+#		define XXH_VECTOR 2 /* AVX2 for Haswell and Bulldozer */
+#	elif defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))
+#		define XXH_VECTOR 1 /* SSE2 for Pentium 4 and all x86_64 */
+#	else
+#		define XXH_VECTOR 0 /* Portable scalar version */
+#	endif
+#endif
+
+		constexpr int vector_mode = XXH_VECTOR;
+
+#if XXH_VECTOR == 3		/* AVX512 for Skylake and Icelake */
+		constexpr int acc_align = 64;
+		using avx512_underlying = __m512i;
+		using avx2_underlying = __m256i;
+		using sse2_underlying = __m128i;
+#elif XXH_VECTOR == 2		/* AVX2 for Haswell and Bulldozer */
+		constexpr int acc_align = 32;
+		using avx512_underlying = void;
+		using avx2_underlying = __m256i;
+		using sse2_underlying = __m128i;
+#elif XXH_VECTOR == 1	/* SSE2 for Pentium 4 and all x86_64 */
+		using avx512_underlying = void;
+		using avx2_underlying = void; //std::array<__m128i, 2>;
+		using sse2_underlying = __m128i;
+		constexpr int acc_align = 16;
+#else					/* Portable scalar version */
+		using avx512_underlying = void;
+		using avx2_underlying = void; //std::array<uint64_t, 4>;
+		using sse2_underlying = void; //std::array<uint64_t, 2>;
+		constexpr int acc_align = 8;
+#endif
+
+
+		/* Compiler Specifics
+		* Defines inline macros and includes specific compiler's instrinsics.
+		* */
+#ifdef XXH_FORCE_INLINE /* First undefining the symbols in case they're already defined */
+#	undef XXH_FORCE_INLINE
+#endif 
+#ifdef XXH_NO_INLINE
+#	undef XXH_NO_INLINE
+#endif
+
+#ifdef _MSC_VER    /* Visual Studio */
+#	pragma warning(disable : 4127)    
+#	define XXH_FORCE_INLINE static __forceinline
+#	define XXH_NO_INLINE static __declspec(noinline)
+#	include <intrin.h>
+#elif defined(__GNUC__)  /* Clang / GCC */
+#	define XXH_FORCE_INLINE static inline __attribute__((always_inline))
+#	define XXH_NO_INLINE static __attribute__((noinline))
+#if (defined(__ARM_NEON) && defined(__APPLE__))
+#  include "sse2neon.h"
+# else
+#  include <immintrin.h>
+# endif
+#else
+#	define XXH_FORCE_INLINE static inline
+#	define XXH_NO_INLINE static
+#endif
+
+
+		/* Prefetch
+		* Can be disabled by defining XXH_NO_PREFETCH
+		*/
+#if defined(XXH_NO_PREFETCH)
+		XXH_FORCE_INLINE void prefetch(const void* ptr) {}
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))  
+		XXH_FORCE_INLINE void prefetch(const void* ptr) { _mm_prefetch((const char*)(ptr), _MM_HINT_T0); }
+#elif defined(__GNUC__) 
+		XXH_FORCE_INLINE void prefetch(const void* ptr) { __builtin_prefetch((ptr), 0, 3); }
+#else
+		XXH_FORCE_INLINE void prefetch(const void* ptr) {}
+#endif
+
+
+		/* Restrict
+		* Defines macro for restrict, which in C++ is sadly just a compiler extension (for now).
+		* Can be disabled by defining XXH_NO_RESTRICT
+		*/
+#ifdef XXH_RESTRICT
+#	undef XXH_RESTRICT
+#endif
+
+#if (defined(__GNUC__) || defined(_MSC_VER)) && defined(__cplusplus) && !defined(XXH_NO_RESTRICT)
+#	define XXH_RESTRICT  __restrict
+#else
+#	define XXH_RESTRICT 
+#endif
+
+
+		/* Likely / Unlikely
+		* Defines macros for Likely / Unlikely, which are official in C++20, but sadly this library aims the previous standard.
+		* Not present on MSVC.
+		* Can be disabled by defining XXH_NO_BRANCH_HINTS
+		*/
+#if ((defined(__GNUC__) && (__GNUC__ >= 3))  || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)) && !defined(XXH_NO_BRANCH_HINTS)
+#    define XXH_likely(x) __builtin_expect(x, 1)
+#    define XXH_unlikely(x) __builtin_expect(x, 0)
+#else
+#    define XXH_likely(x) (x)
+#    define XXH_unlikely(x) (x)
+#endif
+
+
+		namespace bit_ops
+		{
+#if defined(_MSC_VER)
+			static inline uint32_t rotl32(uint32_t x, int32_t r) { return _rotl(x, r); }
+			static inline uint64_t rotl64(uint64_t x, int32_t r) { return _rotl64(x, r); }
+			static inline uint32_t rotr32(uint32_t x, int32_t r) { return _rotr(x, r); }
+			static inline uint64_t rotr64(uint64_t x, int32_t r) { return _rotr64(x, r); }
+#else
+			static inline uint32_t rotl32(uint32_t x, int32_t r) { return ((x << r) | (x >> (32 - r))); }
+			static inline uint64_t rotl64(uint64_t x, int32_t r) { return ((x << r) | (x >> (64 - r))); }
+			static inline uint32_t rotr32(uint32_t x, int32_t r) { return ((x >> r) | (x << (32 - r))); }
+			static inline uint64_t rotr64(uint64_t x, int32_t r) { return ((x >> r) | (x << (64 - r))); }
+#endif
+
+
+#if defined(_MSC_VER)     /* Visual Studio */
+			static inline uint32_t swap32(uint32_t x) { return _byteswap_ulong(x); }
+			static inline uint64_t swap64(uint64_t x) { return _byteswap_uint64(x); }
+#elif defined(__GNUC__)
+			static inline uint32_t swap32(uint32_t x) { return __builtin_bswap32(x); }
+			static inline uint64_t swap64(uint64_t x) { return __builtin_bswap64(x); }
+#else
+			static inline uint32_t swap32(uint32_t x) { return ((x << 24) & 0xff000000) | ((x << 8) & 0x00ff0000) | ((x >> 8) & 0x0000ff00) | ((x >> 24) & 0x000000ff); }
+			static inline uint64_t swap64(uint64_t x) { return ((x << 56) & 0xff00000000000000ULL) | ((x << 40) & 0x00ff000000000000ULL) | ((x << 24) & 0x0000ff0000000000ULL) | ((x << 8) & 0x000000ff00000000ULL) | ((x >> 8) & 0x00000000ff000000ULL) | ((x >> 24) & 0x0000000000ff0000ULL) | ((x >> 40) & 0x000000000000ff00ULL) | ((x >> 56) & 0x00000000000000ffULL); }
+#endif
+
+
+#if defined(_MSC_VER) && defined(_M_IX86) // Only for 32-bit MSVC.
+			XXH_FORCE_INLINE uint64_t mult32to64(uint32_t x, uint32_t y) { return __emulu(x, y); }
+#else
+			XXH_FORCE_INLINE uint64_t mult32to64(uint32_t x, uint32_t y) { return (uint64_t)(uint32_t)(x) * (uint64_t)(uint32_t)(y); }
+#endif
+
+
+#if defined(__GNUC__) && !defined(__clang__) && defined(__i386__)
+			__attribute__((__target__("no-sse")))
+#endif
+			static inline uint128_t mult64to128(uint64_t lhs, uint64_t rhs)
+			{
+
+#if defined(__GNUC__) && !defined(__wasm__) \
+    && defined(__SIZEOF_INT128__) \
+    || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)
+
+				__uint128_t product = (__uint128_t)lhs * (__uint128_t)rhs;
+				uint128_t r128;
+				r128.low64 = (uint64_t)(product);
+				r128.high64 = (uint64_t)(product >> 64);
+				return r128;
+
+#elif defined(_M_X64) || defined(_M_IA64)
+
+#ifndef _MSC_VER
+#   pragma intrinsic(_umul128)
+#endif
+				uint64_t product_high;
+				uint64_t const product_low = _umul128(lhs, rhs, &product_high);
+				uint128_t r128;
+				r128.low64 = product_low;
+				r128.high64 = product_high;
+				return r128;
+
+#else
+				uint64_t const lo_lo = bit_ops::mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);
+				uint64_t const hi_lo = bit_ops::mult32to64(lhs >> 32, rhs & 0xFFFFFFFF);
+				uint64_t const lo_hi = bit_ops::mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);
+				uint64_t const hi_hi = bit_ops::mult32to64(lhs >> 32, rhs >> 32);
+
+				/* Now add the products together. These will never overflow. */
+				uint64_t const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;
+				uint64_t const upper = (hi_lo >> 32) + (cross >> 32) + hi_hi;
+				uint64_t const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);
+
+				uint128_t r128;
+				r128.low64 = lower;
+				r128.high64 = upper;
+				return r128;
+#endif
+			}
+		}
+	}
+
+
+	/* *************************************
+	*  Basic Types - Everything else
+	***************************************/
+
+	namespace typedefs
+	{
+		/* *************************************
+		*  Basic Types - Detail
+		***************************************/
+
+		template <size_t N>
+		struct hash_type
+		{
+			using type = void;
+		};
+
+		template <>
+		struct hash_type<32>
+		{
+			using type = uint32_t;
+		};
+
+		template <>
+		struct hash_type<64>
+		{
+			using type = uint64_t;
+		};
+
+		template <>
+		struct hash_type<128>
+		{
+			using type = uint128_t;
+		};
+
+
+		template <size_t N>
+		struct vec_type
+		{
+			using type = void;
+		};
+
+		template <>
+		struct vec_type<64>
+		{
+			using type = uint64_t;
+		};
+
+		template <>
+		struct vec_type<128>
+		{
+			using type = intrin::sse2_underlying;
+		};
+
+		template <>
+		struct vec_type<256>
+		{
+			using type = intrin::avx2_underlying;
+		};
+
+		template <>
+		struct vec_type<512>
+		{
+			using type = intrin::avx512_underlying;
+		};
+
+		/* Rationale
+		* On the surface level uint_type appears to be pointless,
+		* as it is just a copy of hash_type. They do use the same types,
+		* that is true, but the reasoning for the difference is aimed at humans,
+		* not the compiler, as a difference between values that are 'just' numbers,
+		* and those that represent actual hash values.
+		*/
+		template <size_t N>
+		struct uint_type
+		{
+			using type = void;
+		};
+
+		template <>
+		struct uint_type<32>
+		{
+			using type = uint32_t;
+		};
+
+		template <>
+		struct uint_type<64>
+		{
+			using type = uint64_t;
+		};
+
+		template <>
+		struct uint_type<128>
+		{
+			using type = uint128_t;
+		};
+	}
+
+	template <size_t N>
+	using hash_t = typename typedefs::hash_type<N>::type;
+	using hash32_t = hash_t<32>;
+	using hash64_t = hash_t<64>;
+	using hash128_t = hash_t<128>;
+
+	template <size_t N>
+	using vec_t = typename typedefs::vec_type<N>::type;
+	using vec64_t = vec_t<64>;
+	using vec128_t = vec_t<128>;
+	using vec256_t = vec_t<256>;
+	using vec512_t = vec_t<512>;
+
+	template <size_t N>
+	using uint_t = typename typedefs::uint_type<N>::type;
+	
+
+
+	/* *************************************
+	*  Bit Operations
+	***************************************/
+
+	namespace bit_ops
+	{
+		/* ****************************************
+		*  Bit Operations
+		******************************************/
+
+		template <size_t N>
+		static inline uint_t<N> rotl(uint_t<N> n, int32_t r)
+		{
+			if constexpr (N == 32)
+			{
+				return intrin::bit_ops::rotl32(n, r);
+			}
+
+			if constexpr (N == 64)
+			{
+				return intrin::bit_ops::rotl64(n, r);
+			}
+		}
+
+		template <size_t N>
+		static inline uint_t<N> rotr(uint_t<N> n, int32_t r)
+		{
+			if constexpr (N == 32)
+			{
+				return intrin::bit_ops::rotr32(n, r);
+			}
+
+			if constexpr (N == 64)
+			{
+				return intrin::bit_ops::rotr64(n, r);
+			}
+		}
+
+		template <size_t N>
+		static inline uint_t<N> swap(uint_t<N> n)
+		{
+			if constexpr (N == 32)
+			{
+				return intrin::bit_ops::swap32(n);
+			}
+
+			if constexpr (N == 64)
+			{
+				return intrin::bit_ops::swap64(n);
+			}
+		}
+
+		template <size_t N = 64>
+		static inline vec_t<N> mul32to64(vec_t<N> x, vec_t<N> y)
+		{ 
+			if constexpr (N == 64)
+			{
+				return intrin::bit_ops::mult32to64(static_cast<uint32_t>(x), static_cast<uint32_t>(y));
+			}
+			else
+			{
+				return 0;
+			}
+		}
+
+		static inline uint128_t mul64to128(uint64_t x, uint64_t y)
+		{ 
+			return intrin::bit_ops::mult64to128(x, y); 
+		}
+
+		static inline uint64_t mul128fold64(uint64_t x, uint64_t y)
+		{
+			uint128_t product = mul64to128(x, y);
+
+			return (product.low64 ^ product.high64);
+		}
+	}
+
+
+	/* *************************************
+	*  Memory Functions 
+	***************************************/
+
+	namespace mem_ops
+	{
+
+		/* *************************************
+		* Endianness
+		***************************************/
+
+		constexpr bool is_little_endian()
+		{
+			return (XXH_CPU_LITTLE_ENDIAN == 1);
+		}
+
+
+		/* *************************************
+		*  Memory Access
+		***************************************/
+
+		template <size_t N>
+		static inline uint_t<N> read(const void* memPtr)
+		{
+			uint_t<N> val;
+
+			memcpy(&val, memPtr, sizeof(val));
+			return val;
+		}
+
+		template <size_t N>
+		static inline uint_t<N> readLE(const void* ptr)
+		{
+			if constexpr (is_little_endian())
+			{
+				return read<N>(ptr);
+			}
+			else
+			{
+				return bit_ops::swap<N>(read<N>(ptr));
+			}
+		}
+
+		template <size_t N>
+		static inline uint_t<N> readBE(const void* ptr)
+		{
+			if constexpr (is_little_endian())
+			{
+				return bit_ops::swap<N>(read<N>(ptr));
+			}
+			else
+			{
+				return read<N>(ptr);
+			}
+		}
+
+		template <size_t N>
+		static void writeLE(void* dst, uint_t<N> v)
+		{
+			if constexpr (!is_little_endian())
+			{
+				v = bit_ops::swap<N>(v);
+			}
+
+			memcpy(dst, &v, sizeof(v));
+		}
+	}
+
+
+	/* *************************************
+	*  Vector Functions 
+	***************************************/
+
+	namespace vec_ops
+	{
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> loadu(const vec_t<N>* input)
+		{ 
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid template argument passed to xxh::vec_ops::loadu");
+
+			if constexpr (N == 128)
+			{
+				return _mm_loadu_si128(input);
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_loadu_si256(input);
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_loadu_si512(input);
+			}
+
+			if constexpr (N == 64)
+			{
+				return mem_ops::readLE<64>(input);
+			}
+
+		}
+
+
+		// 'xorv' instead of 'xor' because 'xor' is a weird wacky alternate operator expression thing. 
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> xorv(vec_t<N> a, vec_t<N> b)
+		{ 
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::xorv");
+		
+			if constexpr (N == 128)
+			{
+				return _mm_xor_si128(a, b);
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_xor_si256(a, b);
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_xor_si512(a, b);
+			}
+
+			if constexpr (N == 64)
+			{
+				return a ^ b;
+			}
+		}
+		
+
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> mul(vec_t<N> a, vec_t<N> b)
+		{
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::mul");
+
+			if constexpr (N == 128)
+			{
+				return _mm_mul_epu32(a, b);
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_mul_epu32(a, b);
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_mul_epu32(a, b);
+			}
+
+			if constexpr (N == 64)
+			{
+				return a * b;
+			}
+		}
+
+
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> add(vec_t<N> a, vec_t<N> b)
+		{
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::add");
+
+			if constexpr (N == 128)
+			{
+				return _mm_add_epi64(a, b);
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_add_epi64(a, b);
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_add_epi64(a, b);
+			}
+
+			if constexpr (N == 64)
+			{
+				return a + b;
+			}
+		}
+
+
+		template <size_t N, uint8_t S1, uint8_t S2, uint8_t S3, uint8_t S4>
+		XXH_FORCE_INLINE vec_t<N> shuffle(vec_t<N> a)
+		{ 
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::shuffle");
+
+			if constexpr (N == 128)
+			{
+				return _mm_shuffle_epi32(a, _MM_SHUFFLE(S1, S2, S3, S4));
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_shuffle_epi32(a, _MM_SHUFFLE(S1, S2, S3, S4));
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_shuffle_epi32(a, _MM_SHUFFLE(S1, S2, S3, S4));
+			}
+
+			if constexpr (N == 64)
+			{
+				return a;
+			}
+		}
+
+
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> set1(int64_t a)
+		{
+			
+#if (defined(__ARM_NEON) && defined(__APPLE__))
+      static_assert(!(N != 128 && N != 64), "Invalid argument passed to xxh::vec_ops::set1");
+#else
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::set1");
+			if constexpr (N == 256)
+			{
+				return _mm256_set1_epi32(static_cast<int>(a));
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_set1_epi32(static_cast<int>(a));
+      }
+#endif
+      
+			if constexpr (N == 128)
+			{
+				return _mm_set1_epi32(static_cast<int>(a));
+			}
+
+			if constexpr (N == 64)
+			{
+				return a;
+			}
+		}
+
+
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> srli(vec_t<N> n, int a)
+		{
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::srli");
+
+			if constexpr (N == 128)
+			{
+				return _mm_srli_epi64(n, a);
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_srli_epi64(n, a);
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_srli_epi64(n, a);
+			}
+
+			if constexpr (N == 64)
+			{
+				return n >> a;
+			}
+		}
+
+
+		template <size_t N>
+		XXH_FORCE_INLINE vec_t<N> slli(vec_t<N> n, int a)
+		{
+			static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::slli");
+
+			if constexpr (N == 128)
+			{
+				return _mm_slli_epi64(n, a);
+			}
+
+			if constexpr (N == 256)
+			{
+				return _mm256_slli_epi64(n, a);
+			}
+
+			if constexpr (N == 512)
+			{
+				return _mm512_slli_epi64(n, a);
+			}
+
+			if constexpr (N == 64)
+			{
+				return n << a;
+			}
+		}
+	}
+
+	/* *************************************
+	*  Canonical represenation
+	***************************************/
+
+	template <size_t bit_mode>
+	struct canonical_t
+	{
+		std::array<uint8_t, bit_mode / 8> digest{ 0 };
+
+		canonical_t(hash_t<bit_mode> hash)
+		{
+			if constexpr (bit_mode < 128)
+			{
+				if (mem_ops::is_little_endian())
+				{
+					hash = bit_ops::swap<bit_mode>(hash);
+				}
+
+				memcpy(digest.data(), &hash, sizeof(canonical_t<bit_mode>));
+			}
+			else
+			{
+				if (mem_ops::is_little_endian())
+				{
+					hash.low64 = bit_ops::swap<64>(hash.low64);
+					hash.high64 = bit_ops::swap<64>(hash.high64);
+				}
+
+				memcpy(digest.data(), &hash.high64, sizeof(hash.high64));
+				memcpy(digest.data() + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
+			}
+		}
+
+		hash_t<bit_mode> get_hash() const
+		{
+			if constexpr (bit_mode < 128)
+			{
+				return mem_ops::readBE<bit_mode>(&digest);
+			}
+			else
+			{
+				return { mem_ops::readBE<64>(&digest[8]), mem_ops::readBE<64>(&digest) };
+			}
+		}
+	};
+
+	using canonical32_t = canonical_t<32>;
+	using canonical64_t = canonical_t<64>;
+	using canonical128_t = canonical_t<128>;
+
+	template <size_t bit_mode>
+	inline hash_t<bit_mode> to_canonical(hash_t<bit_mode> hash)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64 && bit_mode != 32), "Canonical form can only be obtained from 32, 64 and 128 bit hashes.");
+		canonical_t<bit_mode> canon(hash);
+		hash_t<bit_mode> res;
+		memcpy(&res, &canon, bit_mode / 8);
+
+		return res;
+	}
+
+
+	/* *************************************
+	*  Algorithm Implementation - xxhash
+	***************************************/
+
+	namespace detail
+	{
+		using namespace mem_ops;
+		using namespace bit_ops;
+
+
+		/* *************************************
+		*  Constants
+		***************************************/
+
+		constexpr static std::array<uint32_t, 5> primes32 = { 2654435761U, 2246822519U, 3266489917U, 668265263U, 374761393U };
+		constexpr static std::array<uint64_t, 5> primes64 = { 11400714785074694791ULL, 14029467366897019727ULL, 1609587929392839161ULL, 9650029242287828579ULL, 2870177450012600261ULL };
+
+		template <size_t N>
+		constexpr uint_t<N> PRIME(uint64_t n) 
+		{
+			if constexpr (N == 32)
+			{
+				return primes32[n - 1];
+			}
+			else
+			{
+				return primes64[n - 1];
+			}
+		}
+
+
+		/* *************************************
+		*  Functions
+		***************************************/
+
+		template <size_t N> 
+		XXH_FORCE_INLINE uint_t<N> avalanche(uint_t<N> hash)
+		{
+			if constexpr (N == 32)
+			{
+				hash ^= hash >> 15;
+				hash *= PRIME<32>(2);
+				hash ^= hash >> 13;
+				hash *= PRIME<32>(3);
+				hash ^= hash >> 16;
+				return hash;
+			}
+			else if constexpr (N == 64)
+			{
+				hash ^= hash >> 33;
+				hash *= PRIME<64>(2);
+				hash ^= hash >> 29;
+				hash *= PRIME<64>(3);
+				hash ^= hash >> 32;
+				return hash;
+			}
+			else return 0;
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE uint_t<N> round(uint_t<N> seed, uint_t<N> input)
+		{
+			seed += input * PRIME<N>(2);
+
+			if constexpr (N == 32)
+			{
+				seed = rotl<N>(seed, 13);
+			}
+			else
+			{
+				seed = rotl<N>(seed, 31);
+			}
+
+			seed *= PRIME<N>(1);
+			return seed;
+		}
+
+		XXH_FORCE_INLINE uint64_t mergeRound64(hash64_t acc, uint64_t val)
+		{
+			val = round<64>(0, val);
+			acc ^= val;
+			acc = acc * PRIME<64>(1) + PRIME<64>(4);
+			return acc;
+		}
+
+		XXH_FORCE_INLINE void endian_align_sub_mergeround(hash64_t& hash_ret, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4)
+		{
+			hash_ret = mergeRound64(hash_ret, v1);
+			hash_ret = mergeRound64(hash_ret, v2);
+			hash_ret = mergeRound64(hash_ret, v3);
+			hash_ret = mergeRound64(hash_ret, v4);
+		}
+
+		template <size_t N>
+		static inline hash_t<N> endian_align_sub_ending(hash_t<N> hash_ret, const uint8_t* p, const uint8_t* bEnd)
+		{
+			if constexpr (N == 32)
+			{
+				while ((p + 4) <= bEnd)
+				{
+					hash_ret += readLE<32>(p) * PRIME<32>(3);
+					hash_ret = rotl<32>(hash_ret, 17) * PRIME<32>(4);
+					p += 4;
+				}
+
+				while (p < bEnd)
+				{
+					hash_ret += (*p) * PRIME<32>(5);
+					hash_ret = rotl<32>(hash_ret, 11) * PRIME<32>(1);
+					p++;
+				}
+
+				return avalanche<32>(hash_ret);
+			}
+			else
+			{
+				while (p + 8 <= bEnd)
+				{
+					const uint64_t k1 = round<64>(0, readLE<64>(p));
+
+					hash_ret ^= k1;
+					hash_ret = rotl<64>(hash_ret, 27) * PRIME<64>(1) + PRIME<64>(4);
+					p += 8;
+				}
+
+				if (p + 4 <= bEnd)
+				{
+					hash_ret ^= static_cast<uint64_t>(readLE<32>(p))* PRIME<64>(1);
+					hash_ret = rotl<64>(hash_ret, 23) * PRIME<64>(2) + PRIME<64>(3);
+					p += 4;
+				}
+
+				while (p < bEnd)
+				{
+					hash_ret ^= (*p) * PRIME<64>(5);
+					hash_ret = rotl<64>(hash_ret, 11) * PRIME<64>(1);
+					p++;
+				}
+
+				return avalanche<64>(hash_ret);
+			}
+		}
+
+		template <size_t N>
+		static inline hash_t<N> endian_align(const void* input, size_t len, uint_t<N> seed)
+		{
+			static_assert(!(N != 32 && N != 64), "You can only call endian_align in 32 or 64 bit mode.");
+
+			const uint8_t* p = static_cast<const uint8_t*>(input);
+			const uint8_t* bEnd = p + len;
+			hash_t<N> hash_ret;
+
+			if (len >= (N / 2))
+			{
+				const uint8_t* const limit = bEnd - (N / 2);
+				uint_t<N> v1 = seed + PRIME<N>(1) + PRIME<N>(2);
+				uint_t<N> v2 = seed + PRIME<N>(2);
+				uint_t<N> v3 = seed + 0;
+				uint_t<N> v4 = seed - PRIME<N>(1);
+
+				do
+				{
+					v1 = round<N>(v1, readLE<N>(p)); 
+					p += (N / 8);
+					v2 = round<N>(v2, readLE<N>(p)); 
+					p += (N / 8);
+					v3 = round<N>(v3, readLE<N>(p)); 
+					p += (N / 8);
+					v4 = round<N>(v4, readLE<N>(p)); 
+					p += (N / 8);
+				} 
+				while (p <= limit);
+
+				hash_ret = rotl<N>(v1, 1) + rotl<N>(v2, 7) + rotl<N>(v3, 12) + rotl<N>(v4, 18);
+
+				if constexpr (N == 64)
+				{
+					endian_align_sub_mergeround(hash_ret, v1, v2, v3, v4);
+				}
+			}
+			else 
+			{ 
+				hash_ret = seed + PRIME<N>(5); 
+			}
+
+			hash_ret += static_cast<hash_t<N>>(len);
+
+			return endian_align_sub_ending<N>(hash_ret, p, bEnd);
+		}
+	}
+
+
+	/* *************************************
+	*  Algorithm Implementation - xxhash3
+	***************************************/
+
+	namespace detail3
+	{
+		using namespace vec_ops;
+		using namespace detail;
+		using namespace mem_ops;
+		using namespace bit_ops;
+
+
+		/* *************************************
+		*  Enums
+		***************************************/
+
+		enum class vec_mode : uint8_t { scalar = 0, sse2 = 1, avx2 = 2, avx512 = 3 };
+
+
+		/* *************************************
+		*  Constants
+		***************************************/
+
+		constexpr uint64_t secret_default_size = 192;
+		constexpr uint64_t secret_size_min = 136;
+		constexpr uint64_t secret_consume_rate = 8;
+		constexpr uint64_t stripe_len = 64;
+		constexpr uint64_t acc_nb = 8;
+		constexpr uint64_t prefetch_distance = 384;
+		constexpr uint64_t secret_lastacc_start = 7;
+		constexpr uint64_t secret_mergeaccs_start = 11;
+		constexpr uint64_t midsize_max = 240;
+		constexpr uint64_t midsize_startoffset = 3;
+		constexpr uint64_t midsize_lastoffset = 17;
+
+		constexpr vec_mode vector_mode = static_cast<vec_mode>(intrin::vector_mode);
+		constexpr uint64_t acc_align = intrin::acc_align;
+		constexpr std::array<uint64_t, 4> vector_bit_width { 64, 128, 256, 512 };
+
+		
+		/* *************************************
+		*  Defaults
+		***************************************/
+		
+		alignas(64) constexpr uint8_t default_secret[secret_default_size] = {
+			0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
+			0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
+			0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
+			0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
+			0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
+			0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
+			0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
+			0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
+			0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
+			0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
+			0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
+			0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
+		};
+
+		constexpr std::array<uint64_t, 8> init_acc = { PRIME<32>(3), PRIME<64>(1), PRIME<64>(2), PRIME<64>(3), PRIME<64>(4), PRIME<32>(2), PRIME<64>(5), PRIME<32>(1) };
+	
+
+		/* *************************************
+		*  Functions
+		***************************************/
+	
+		XXH_FORCE_INLINE hash_t<64> avalanche(hash_t<64> h64)
+		{
+			constexpr uint64_t avalanche_mul_prime = 0x165667919E3779F9ULL;
+
+			h64 ^= h64 >> 37;
+			h64 *= avalanche_mul_prime;
+			h64 ^= h64 >> 32;
+			return h64;
+		}
+
+		XXH_FORCE_INLINE hash_t<64> rrmxmx(hash_t<64> h64, uint64_t len)
+		{
+			h64 ^= rotl<64>(h64, 49) ^ rotl<64>(h64, 24);
+			h64 *= 0x9FB21C651E98DF25ULL;
+			h64 ^= (h64 >> 35) + len;
+			h64 *= 0x9FB21C651E98DF25ULL;
+			h64 ^= (h64 >> 28);
+			return h64;
+		}
+
+		XXH_FORCE_INLINE void combine_16(void* dest, hash128_t h128)
+		{
+			writeLE<64>(dest, readLE<64>(dest) ^ h128.low64);
+			writeLE<64>((uint8_t*)dest + 8, readLE<64>((uint8_t*)dest + 8) ^ h128.high64);
+		}
+
+		XXH_FORCE_INLINE void accumulate_512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret)
+		{
+			constexpr uint64_t bits = vector_bit_width[static_cast<uint8_t>(vector_mode)];
+
+			using vec_t = vec_t<bits>;
+			
+			alignas(sizeof(vec_t)) vec_t* const xacc = static_cast<vec_t*>(acc);
+			const vec_t* const xinput = static_cast<const vec_t*>(input);
+			const vec_t* const xsecret = static_cast<const vec_t*>(secret);
+
+			for (size_t i = 0; i < stripe_len / sizeof(vec_t); i++)
+			{
+				vec_t const data_vec = loadu<bits>(xinput + i);
+				vec_t const key_vec = loadu<bits>(xsecret + i);
+				vec_t const data_key = xorv<bits>(data_vec, key_vec);
+				vec_t product = set1<bits>(0);
+
+				if constexpr (vector_mode == vec_mode::scalar)
+				{
+					product = mul32to64<bits>(srli<bits>(slli<bits>(data_key, 32),32), srli<bits>(data_key, 32));
+					xacc[i ^ 1] = add<bits>(xacc[i ^ 1], data_vec);
+					xacc[i] = add<bits>(xacc[i], product);
+				}
+				else
+				{
+					vec_t const data_key_lo = shuffle<bits, 0, 3, 0, 1>(data_key);
+					product = mul<bits>(data_key, data_key_lo);
+
+					vec_t const data_swap = shuffle<bits, 1, 0, 3, 2>(data_vec);
+					vec_t const sum = add<bits>(xacc[i], data_swap);
+					xacc[i] = add<bits>(sum, product);
+				}				
+			}
+		}
+
+		XXH_FORCE_INLINE void scramble_acc(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+		{
+			constexpr uint64_t bits = vector_bit_width[static_cast<uint8_t>(vector_mode)];;
+
+			using vec_t = vec_t<bits>;
+
+			alignas(sizeof(vec_t)) vec_t* const xacc = (vec_t*)acc;
+			const vec_t* const xsecret = (const vec_t*)secret;  
+
+			for (size_t i = 0; i < stripe_len / sizeof(vec_t); i++)
+			{
+				vec_t const acc_vec = xacc[i];
+				vec_t const shifted = srli<bits>(acc_vec, 47);
+				vec_t const data_vec = xorv<bits>(acc_vec, shifted);
+				vec_t const key_vec = loadu<bits>(xsecret + i);
+				vec_t const data_key = xorv<bits>(data_vec, key_vec);
+				
+				if constexpr (vector_mode == vec_mode::scalar)
+				{
+					xacc[i] = mul<bits>(data_key, set1<bits>(PRIME<32>(1)));
+				}
+				else
+				{
+					vec_t const prime32 = set1<bits>(PRIME<32>(1));
+					vec_t const data_key_hi = shuffle<bits, 0, 3, 0, 1>(data_key);
+					vec_t const prod_lo = mul<bits>(data_key, prime32);
+					vec_t const prod_hi = mul<bits>(data_key_hi, prime32);
+
+					xacc[i] = add<bits>(prod_lo, vec_ops::slli<bits>(prod_hi, 32));
+				}
+			}
+		}
+
+		XXH_FORCE_INLINE void accumulate(uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT input, const uint8_t* XXH_RESTRICT secret, size_t nbStripes)
+		{
+			for (size_t n = 0; n < nbStripes; n++) 
+			{
+				const uint8_t* const in = input + n * stripe_len;
+
+				intrin::prefetch(in + prefetch_distance);
+				accumulate_512(acc, in, secret + n * secret_consume_rate);
+			}
+		}
+
+		XXH_FORCE_INLINE void hash_long_internal_loop(uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret, size_t secretSize)
+		{
+			size_t const nb_rounds = (secretSize - stripe_len) / secret_consume_rate;
+			size_t const block_len = stripe_len * nb_rounds;
+			size_t const nb_blocks = (len-1) / block_len;
+
+			for (size_t n = 0; n < nb_blocks; n++) 
+			{
+				accumulate(acc, input + n * block_len, secret, nb_rounds);
+				scramble_acc(acc, secret + secretSize - stripe_len);
+			}
+
+			/* last partial block */
+			size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / stripe_len;
+
+			accumulate(acc, input + nb_blocks * block_len, secret, nbStripes);
+
+			/* last stripe */
+			const uint8_t* const p = input + len - stripe_len;
+
+			accumulate_512(acc, p, secret + secretSize - stripe_len - secret_lastacc_start);
+		}
+
+		XXH_FORCE_INLINE uint64_t mix_2_accs(const uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT secret)
+		{
+			return mul128fold64(acc[0] ^ readLE<64>(secret), acc[1] ^ readLE<64>(secret + 8));
+		}
+
+		XXH_FORCE_INLINE uint64_t merge_accs(const uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT secret, uint64_t start)
+		{
+			uint64_t result64 = start;
+
+			result64 += mix_2_accs(acc + 0, secret + 0);
+			result64 += mix_2_accs(acc + 2, secret + 16);
+			result64 += mix_2_accs(acc + 4, secret + 32);
+			result64 += mix_2_accs(acc + 6, secret + 48);
+
+			return avalanche(result64);
+		}
+
+		XXH_FORCE_INLINE void init_custom_secret(uint8_t* customSecret, uint64_t seed)
+		{
+			for (uint64_t i = 0; i < secret_default_size / 16; i++) 
+			{
+				writeLE<64>(customSecret + i * 16, readLE<64>(default_secret + i * 16) + seed);
+				writeLE<64>(customSecret + i * 16 + 8, readLE<64>(default_secret + i * 16 + 8) - seed);
+			}
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE hash_t<N> len_1to3(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
+		{
+			if constexpr (N == 64)
+			{
+				uint8_t const c1 = input[0];
+				uint8_t const c2 = input[len >> 1];
+				uint8_t const c3 = input[len - 1];
+				uint32_t const combined = ((uint32_t)c1 << 16) | (((uint32_t)c2) << 24) | (((uint32_t)c3) << 0) | (((uint32_t)len) << 8);
+				uint64_t const bitflip = (readLE<32>(secret) ^ readLE<32>(secret + 4)) + seed;
+				uint64_t const keyed = (uint64_t)combined ^ bitflip;
+				return detail::avalanche<64>(keyed);
+			}
+			else
+			{
+				uint8_t const c1 = input[0];
+				uint8_t const c2 = input[len >> 1];
+				uint8_t const c3 = input[len - 1];
+				uint32_t const combinedl = ((uint32_t)c1 << 16) + (((uint32_t)c2) << 24) + (((uint32_t)c3) << 0) + (((uint32_t)len) << 8);
+				uint32_t const combinedh = rotl<32>(swap<32>(combinedl), 13);
+				uint64_t const bitflipl = (readLE<32>(secret) ^ readLE<32>(secret + 4)) + seed;
+				uint64_t const bitfliph = (readLE<32>(secret + 8) ^ readLE<32>(secret + 12)) - seed;
+				uint64_t const keyed_lo = (uint64_t)combinedl ^ bitflipl;
+				uint64_t const keyed_hi = (uint64_t)combinedh ^ bitfliph;
+				hash128_t const h128 = { detail::avalanche<64>(keyed_lo), detail::avalanche<64>(keyed_hi)};
+
+				return h128;
+			}
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE hash_t<N> len_4to8(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
+		{
+			constexpr uint64_t mix_constant = 0x9FB21C651E98DF25ULL;
+
+			seed ^= (uint64_t)swap<32>((uint32_t)seed) << 32;
+
+			if constexpr (N == 64)
+			{		
+				uint32_t const input1 = readLE<32>(input);
+				uint32_t const input2 = readLE<32>(input + len - 4);
+				uint64_t const bitflip = (readLE<64>(secret + 8) ^ readLE<64>(secret + 16)) - seed;
+				uint64_t const input64 = input2 + ((uint64_t)input1 << 32);
+				uint64_t keyed = input64 ^ bitflip;
+			
+				return rrmxmx(keyed, len);
+			}
+			else
+			{
+				uint32_t const input_lo = readLE<32>(input);
+				uint32_t const input_hi = readLE<32>(input + len - 4);
+				uint64_t const input_64 = input_lo + ((uint64_t)input_hi << 32);
+				uint64_t const bitflip = (readLE<64>(secret + 16) ^ readLE<64>(secret + 24)) + seed;
+				uint64_t const keyed = input_64 ^ bitflip;
+				uint128_t m128 = mul64to128(keyed, PRIME<64>(1) + (len << 2));
+
+				m128.high64 += (m128.low64 << 1);
+				m128.low64 ^= (m128.high64 >> 3);
+				m128.low64 ^= (m128.low64 >> 35);
+				m128.low64 *= mix_constant;
+				m128.low64 ^= (m128.low64 >> 28);
+				m128.high64 = avalanche(m128.high64);
+
+				return m128;		
+			}
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE hash_t<N> len_9to16(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
+		{
+			if constexpr (N == 64)
+			{
+				uint64_t const bitflip1 = (readLE<64>(secret + 24) ^ readLE<64>(secret + 32)) + seed;
+				uint64_t const bitflip2 = (readLE<64>(secret + 40) ^ readLE<64>(secret + 48)) - seed;
+				uint64_t const input_lo = readLE<64>(input) ^ bitflip1;
+				uint64_t const input_hi = readLE<64>(input + len - 8) ^ bitflip2;
+				uint64_t const acc = len + swap<64>(input_lo) + input_hi + mul128fold64(input_lo, input_hi);
+
+				return avalanche(acc);
+			}
+			else
+			{
+				uint64_t const bitflipl = (readLE<64>(secret + 32) ^ readLE<64>(secret + 40)) - seed;
+				uint64_t const bitfliph = (readLE<64>(secret + 48) ^ readLE<64>(secret + 56)) + seed;
+				uint64_t const input_lo = readLE<64>(input);
+				uint64_t input_hi = readLE<64>(input + len - 8);
+				uint128_t m128 = mul64to128(input_lo ^ input_hi ^ bitflipl, PRIME<64>(1));
+
+				m128.low64 += (uint64_t)(len - 1) << 54;
+				input_hi ^= bitfliph;
+
+				if constexpr (sizeof(void*) < sizeof(uint64_t)) // 32-bit version
+				{
+					m128.high64 += (input_hi & 0xFFFFFFFF00000000) + mul32to64((uint32_t)input_hi, PRIME<32>(2));
+				}
+				else
+				{
+					m128.high64 += input_hi + mul32to64((uint32_t)input_hi, PRIME<32>(2) - 1);
+				}
+
+				m128.low64 ^= swap<64>(m128.high64);
+
+				hash128_t h128 = mul64to128(m128.low64, PRIME<64>(2));
+
+				h128.high64 += m128.high64 * PRIME<64>(2);
+				h128.low64 = avalanche(h128.low64);
+				h128.high64 = avalanche(h128.high64);
+
+				return h128;
+			}
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE hash_t<N> len_0to16(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
+		{
+			if (XXH_likely(len > 8))
+			{
+				return len_9to16<N>(input, len, secret, seed);
+			}
+			else if (XXH_likely(len >= 4))
+			{
+				return len_4to8<N>(input, len, secret, seed);
+			}
+			else if (len)
+			{
+				return len_1to3<N>(input, len, secret, seed);
+			}
+			else
+			{
+				if constexpr (N == 64)
+				{
+					return detail::avalanche<64>((seed) ^ (readLE<64>(secret + 56) ^ readLE<64>(secret + 64)));
+				}
+				else
+				{
+					uint64_t const bitflipl = readLE<64>(secret + 64) ^ readLE<64>(secret + 72);
+					uint64_t const bitfliph = readLE<64>(secret + 80) ^ readLE<64>(secret + 88);
+
+					return hash128_t(detail::avalanche<64>(( seed) ^ bitflipl), detail::avalanche<64>(( seed) ^ bitfliph));
+				}			
+			}
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE hash_t<N> hash_long_internal(const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret = default_secret, size_t secretSize = sizeof(default_secret))
+		{
+			alignas(acc_align) std::array<uint64_t, acc_nb> acc = init_acc;
+
+			if constexpr (N == 64)
+			{				
+				hash_long_internal_loop(acc.data(), input, len, secret, secretSize);
+
+				/* converge into final hash */
+				return merge_accs(acc.data(), secret + secret_mergeaccs_start, (uint64_t)len * PRIME<64>(1));
+			}
+			else
+			{
+				hash_long_internal_loop(acc.data(), input, len, secret, secretSize);
+
+				/* converge into final hash */
+				uint64_t const low64 = merge_accs(acc.data(), secret + secret_mergeaccs_start, (uint64_t)len * PRIME<64>(1));
+				uint64_t const high64 = merge_accs(acc.data(), secret + secretSize - sizeof(acc) - secret_mergeaccs_start, ~((uint64_t)len * PRIME<64>(2)));
+
+				return hash128_t(low64, high64);
+			}
+		}
+
+		XXH_FORCE_INLINE uint64_t mix_16b(const uint8_t* XXH_RESTRICT input, const uint8_t* XXH_RESTRICT secret, uint64_t seed)
+		{
+			uint64_t const input_lo = readLE<64>(input);
+			uint64_t const input_hi = readLE<64>(input + 8);
+
+			return mul128fold64(input_lo ^ (readLE<64>(secret) + seed), input_hi ^ (readLE<64>(secret + 8) - seed));
+		}
+
+		XXH_FORCE_INLINE uint128_t mix_32b(uint128_t acc, const uint8_t* input1, const uint8_t* input2, const uint8_t* secret, uint64_t seed)
+		{
+			acc.low64 += mix_16b(input1, secret + 0, seed);
+			acc.low64 ^= readLE<64>(input2) + readLE<64>(input2 + 8);
+			acc.high64 += mix_16b(input2, secret + 16, seed);
+			acc.high64 ^= readLE<64>(input1) + readLE<64>(input1 + 8);
+
+			return acc;	
+		}
+
+		template <size_t N>
+		XXH_FORCE_INLINE hash_t<N> len_17to128(const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret, uint64_t seed)
+		{
+			if constexpr (N == 64)
+			{
+				hash64_t acc = len * PRIME<64>(1);
+
+				if (len > 32) 
+				{
+					if (len > 64) 
+					{
+						if (len > 96) 
+						{
+							acc += mix_16b(input + 48, secret + 96, seed);
+							acc += mix_16b(input + len - 64, secret + 112, seed);
+						}
+
+						acc += mix_16b(input + 32, secret + 64, seed);
+						acc += mix_16b(input + len - 48, secret + 80, seed);
+					}
+
+					acc += mix_16b(input + 16, secret + 32, seed);
+					acc += mix_16b(input + len - 32, secret + 48, seed);
+				}
+
+				acc += mix_16b(input + 0, secret + 0, seed);
+				acc += mix_16b(input + len - 16, secret + 16, seed);
+
+				return avalanche(acc);
+			}
+			else
+			{
+				hash128_t acc = { len * PRIME<64>(1), 0 };
+
+				if (len > 32) 
+				{
+					if (len > 64) 
+					{
+						if (len > 96) 
+						{
+							acc = mix_32b(acc, input + 48, input + len - 64, secret + 96, seed);
+						}
+
+						acc = mix_32b(acc, input + 32, input + len - 48, secret + 64, seed);
+					}
+
+					acc = mix_32b(acc, input + 16, input + len - 32, secret + 32, seed);
+				}
+
+				acc = mix_32b(acc, input, input + len - 16, secret, seed);
+
+				uint64_t const low64 = acc.low64 + acc.high64;
+				uint64_t const high64 = (acc.low64 * PRIME<64>(1)) + (acc.high64 * PRIME<64>(4)) + ((len - seed) * PRIME<64>(2));
+
+				return { avalanche(low64), (uint64_t)0 - avalanche(high64) };
+			}
+		}
+
+		template <size_t N>
+		XXH_NO_INLINE hash_t<N> len_129to240(const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret, uint64_t seed)
+		{
+			if constexpr (N == 64)
+			{
+				uint64_t acc = len * PRIME<64>(1);
+				size_t const nbRounds = len / 16;
+
+				for (size_t i = 0; i < 8; i++) 
+				{
+					acc += mix_16b(input + (i * 16), secret + (i * 16), seed);
+				}
+
+				acc = avalanche(acc);
+
+				for (size_t i = 8; i < nbRounds; i++) 
+				{
+					acc += mix_16b(input + (i * 16), secret + ((i - 8) * 16) + midsize_startoffset, seed);
+				}
+
+				/* last bytes */
+				acc += mix_16b(input + len - 16, secret + secret_size_min - midsize_lastoffset, seed);
+
+				return avalanche(acc);
+			}
+			else
+			{
+				hash128_t acc;
+				uint64_t const nbRounds = len / 32;
+
+				acc.low64 = len * PRIME<64>(1);
+				acc.high64 = 0;
+
+				for (size_t i = 0; i < 4; i++) 
+				{
+					acc = mix_32b(acc, input + (i * 32), input + (i * 32) + 16, secret + (i * 32), seed);
+				}
+
+				acc.low64 = avalanche(acc.low64);
+				acc.high64 = avalanche(acc.high64);
+
+				for (size_t i = 4; i < nbRounds; i++) 
+				{
+					acc = mix_32b(acc, input + (i * 32), input + (i * 32) + 16, secret + midsize_startoffset + ((i - 4) * 32), seed);
+				}
+
+				/* last bytes */
+				acc = mix_32b(acc, input + len - 16, input + len - 32, secret + secret_size_min - midsize_lastoffset - 16, 0ULL - seed);
+
+				uint64_t const low64 = acc.low64 + acc.high64;
+				uint64_t const high64 = (acc.low64 * PRIME<64>(1)) + (acc.high64 * PRIME<64>(4)) + ((len - seed) * PRIME<64>(2));
+
+				return { avalanche(low64), (uint64_t)0 - avalanche(high64) };
+			}
+
+		}
+
+		template <size_t N>
+		XXH_NO_INLINE hash_t<N> xxhash3_impl(const void* XXH_RESTRICT input, size_t len, hash64_t seed, const void* XXH_RESTRICT secret = default_secret, size_t secretSize = secret_default_size)
+		{
+
+			alignas(64) uint8_t custom_secret[secret_default_size];
+
+			const void* short_secret = secret;
+		
+			if (seed != 0)
+			{
+				init_custom_secret(custom_secret, seed);
+				short_secret = default_secret;
+			}
+
+			if (len <= 16)
+			{
+				return len_0to16<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(short_secret), seed);
+			}
+			else if (len <= 128)
+			{
+				return len_17to128<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(short_secret), seed);
+			}
+			else if (len <= midsize_max)
+			{
+				return len_129to240<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(short_secret), seed);
+			}
+			else
+			{
+				return hash_long_internal<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(((seed == 0) ? secret : ((secret == default_secret) ? custom_secret : secret))), ((seed == 0) ? secretSize : ((secret == default_secret) ? secret_default_size : secretSize)));
+			}
+		}
+
+		XXH_NO_INLINE void generate_secret(void* secret_buffer, size_t secret_size, const void* custom_seed, size_t seed_size)
+		{
+			if (seed_size == 0)
+			{
+				custom_seed = default_secret;
+				seed_size = secret_default_size;
+			}
+
+			size_t pos = 0;
+			while (pos < secret_size)
+			{
+				size_t const copy_len = std::min(secret_size - pos, seed_size);
+				memcpy((uint8_t*)secret_buffer + pos, custom_seed, copy_len);
+				pos += copy_len;
+			}
+
+			size_t const nbseg16 = secret_size / 16;
+			canonical128_t scrambled(xxhash3_impl<128>(custom_seed, seed_size, 0));
+			for (size_t n = 0; n < nbseg16; n++)
+			{
+				hash128_t const h128 = xxhash3_impl<128>(&scrambled, sizeof(scrambled), n);
+				combine_16((uint8_t*)secret_buffer + n * 16, h128);
+			}
+
+			combine_16((uint8_t*)secret_buffer + secret_size - 16, scrambled.get_hash());
+		}
+	}
+
+
+	/* *************************************
+	*  Public Access Point - xxhash
+	***************************************/
+
+	template <size_t bit_mode>
+	inline hash_t<bit_mode> xxhash(const void* input, size_t len, uint_t<bit_mode> seed = 0)
+	{
+		static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
+		return detail::endian_align<bit_mode>(input, len, seed);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash(const std::basic_string<T>& input, uint_t<bit_mode> seed = 0)
+	{
+		static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
+		return detail::endian_align<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename ContiguousIterator>
+	inline hash_t<bit_mode> xxhash(ContiguousIterator begin, ContiguousIterator end, uint_t<bit_mode> seed = 0)
+	{
+		static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
+		using T = typename std::decay_t<decltype(*end)>;
+		return detail::endian_align<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash(const std::vector<T>& input, uint_t<bit_mode> seed = 0)
+	{
+		static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
+		return detail::endian_align<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T, size_t AN>
+	inline hash_t<bit_mode> xxhash(const std::array<T, AN>& input, uint_t<bit_mode> seed = 0)
+	{
+		static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
+		return detail::endian_align<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash(const std::initializer_list<T>& input, uint_t<bit_mode> seed = 0)
+	{
+		static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
+		return detail::endian_align<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed);
+	}
+
+
+	/* *************************************
+	*  Public Access Point - xxhash3
+	***************************************/
+
+	template <size_t bit_mode>
+	inline hash_t<bit_mode> xxhash3(const void* input, size_t len, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(input, len, seed);
+	}
+
+	template <size_t bit_mode>
+	inline hash_t<bit_mode> xxhash3(const void* input, size_t len, const void* secret, size_t secretSize, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(input, len, seed, secret, secretSize);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, const void* secret, size_t secretSize, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed, secret, secretSize);
+	}
+
+	template <size_t bit_mode, typename ContiguousIterator>
+	inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIterator end, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		using T = typename std::decay_t<decltype(*end)>;
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename ContiguousIterator>
+	inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIterator end, const void* secret, size_t secretSize, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		using T = typename std::decay_t<decltype(*end)>;
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed, secret, secretSize);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, const void* secret, size_t secretSize, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed, secret, secretSize);
+	}
+
+	template <size_t bit_mode, typename T, size_t AN>
+	inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T, size_t AN>
+	inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, const void* secret, size_t secretSize, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), seed, secret, secretSize);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed);
+	}
+
+	template <size_t bit_mode, typename T>
+	inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input, const void* secret, size_t secretSize, uint64_t seed = 0)
+	{
+		static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
+		return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed, secret, secretSize);
+	}
+
+
+	/* *************************************
+	*  Secret Generation Functions
+	***************************************/
+	 
+	inline void generate_secret(void* secret_buffer, size_t secret_size, const void* custom_seed = detail3::default_secret, size_t seed_length = 0)
+	{
+		detail3::generate_secret(secret_buffer, secret_size, custom_seed, seed_length);
+	}
+
+	template <typename T, size_t AN>
+	inline void generate_secret(void* secret_buffer, size_t secret_size, const std::array<T, AN>& custom_seed)
+	{
+		detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.data()), AN * sizeof(T));
+	}
+
+	template <typename T>
+	inline void generate_secret(void* secret_buffer, size_t secret_size, const std::initializer_list<T>& custom_seed)
+	{
+		detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.begin()), custom_seed.size() * sizeof(T));
+	}
+
+	template <typename T>
+	inline void generate_secret(void* secret_buffer, size_t secret_size, const std::vector<T>& custom_seed)
+	{
+		detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.data()), custom_seed.size() * sizeof(T));
+	}
+
+	template <typename T>
+	inline void generate_secret(void* secret_buffer, size_t secret_size, const std::basic_string<T>& custom_seed)
+	{
+		detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.data()), custom_seed.length() * sizeof(T));
+	}
+
+	template <typename ContiguousIterator>
+	inline void generate_secret(void* secret_buffer, size_t secret_size, ContiguousIterator begin, ContiguousIterator end)
+	{
+		using T = typename std::decay_t<decltype(*end)>;
+		detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(&*begin), (end - begin) * sizeof(T));
+	}
+
+	inline void generate_secret_from_seed(void* secret_buffer, uint64_t seed = 0)
+	{
+		alignas(64) uint8_t custom_secret[detail3::secret_default_size];
+		detail3::init_custom_secret(custom_secret, seed);
+		memcpy(secret_buffer, custom_secret, detail3::secret_default_size);
+	}
+
+
+	/* *************************************
+	*  Hash streaming - xxhash
+	***************************************/
+
+	template <size_t bit_mode>
+	class hash_state_t 
+	{
+		uint64_t total_len = 0;
+		uint_t<bit_mode> v1 = 0, v2 = 0, v3 = 0, v4 = 0;
+		std::array<hash_t<bit_mode>, 4> mem = {0, 0, 0, 0};
+		uint32_t memsize = 0;
+
+		inline void update_impl(const void* input, size_t length)
+		{
+			const uint8_t* p = reinterpret_cast<const uint8_t*>(input);
+			const uint8_t* const bEnd = p + length;
+
+			total_len += length;
+
+			if (memsize + length < (bit_mode / 2))
+			{	/* fill in tmp buffer */
+				memcpy(reinterpret_cast<uint8_t*>(mem.data()) + memsize, input, length);
+				memsize += static_cast<uint32_t>(length);
+				return;
+			}
+
+			if (memsize > 0)
+			{	/* some data left from previous update */
+				memcpy(reinterpret_cast<uint8_t*>(mem.data()) + memsize, input, (bit_mode / 2) - memsize);
+
+				const uint_t<bit_mode>* ptr = mem.data();
+
+				v1 = detail::round<bit_mode>(v1, mem_ops::readLE<bit_mode>(ptr)); 
+				ptr++;
+				v2 = detail::round<bit_mode>(v2, mem_ops::readLE<bit_mode>(ptr)); 
+				ptr++;
+				v3 = detail::round<bit_mode>(v3, mem_ops::readLE<bit_mode>(ptr)); 
+				ptr++;
+				v4 = detail::round<bit_mode>(v4, mem_ops::readLE<bit_mode>(ptr));
+
+				p += (bit_mode / 2) - memsize;
+				memsize = 0;
+			}
+
+			while (p + (bit_mode / 2) <= bEnd)
+			{
+				v1 = detail::round<bit_mode>(v1, mem_ops::readLE<bit_mode>(p)); 
+				p += (bit_mode / 8);
+				v2 = detail::round<bit_mode>(v2, mem_ops::readLE<bit_mode>(p)); 
+				p += (bit_mode / 8);
+				v3 = detail::round<bit_mode>(v3, mem_ops::readLE<bit_mode>(p)); 
+				p += (bit_mode / 8);
+				v4 = detail::round<bit_mode>(v4, mem_ops::readLE<bit_mode>(p)); 
+				p += (bit_mode / 8);
+			}
+
+			if (p < bEnd)
+			{
+				memcpy(mem.data(), p, static_cast<size_t>(bEnd - p));
+				memsize = static_cast<uint32_t>(bEnd - p);
+			}
+		}
+
+		inline hash_t<bit_mode> digest_impl() const
+		{
+			const uint8_t* p = reinterpret_cast<const uint8_t*>(mem.data());
+			const uint8_t* const bEnd = reinterpret_cast<const uint8_t*>(mem.data()) + memsize;
+			hash_t<bit_mode> hash_ret;
+
+			if (total_len >= (bit_mode / 2))
+			{
+				hash_ret = bit_ops::rotl<bit_mode>(v1, 1) + bit_ops::rotl<bit_mode>(v2, 7) + bit_ops::rotl<bit_mode>(v3, 12) + bit_ops::rotl<bit_mode>(v4, 18);
+
+				if constexpr (bit_mode == 64)
+				{
+					detail::endian_align_sub_mergeround(hash_ret, v1, v2, v3, v4);
+				}
+			}
+			else 
+			{ 
+				hash_ret = v3 + detail::PRIME<bit_mode>(5); 
+			}
+
+			hash_ret += static_cast<hash_t<bit_mode>>(total_len);
+
+			return detail::endian_align_sub_ending<bit_mode>(hash_ret, p, bEnd);
+		}
+
+	public:
+
+		hash_state_t(uint_t<bit_mode> seed = 0)
+		{
+			static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash streaming can only be used in 32 and 64 bit modes.");
+			v1 = seed + detail::PRIME<bit_mode>(1) + detail::PRIME<bit_mode>(2);
+			v2 = seed + detail::PRIME<bit_mode>(2);
+			v3 = seed + 0;
+			v4 = seed - detail::PRIME<bit_mode>(1);
+		};
+
+		void reset(uint_t<bit_mode> seed = 0)
+		{
+			memset(this, 0, sizeof(hash_state_t<bit_mode>));
+			v1 = seed + detail::PRIME<bit_mode>(1) + detail::PRIME<bit_mode>(2);
+			v2 = seed + detail::PRIME<bit_mode>(2);
+			v3 = seed + 0;
+			v4 = seed - detail::PRIME<bit_mode>(1);
+		}
+
+		void update(const void* input, size_t length)
+		{
+			return update_impl(input, length);
+		}
+
+		template <typename T>
+		void update(const std::basic_string<T>& input)
+		{
+			return update_impl(static_cast<const void*>(input.data()), input.length() * sizeof(T));
+		}
+
+		template <typename ContiguousIterator>
+		void update(ContiguousIterator begin, ContiguousIterator end)
+		{
+			using T = typename std::decay_t<decltype(*end)>;
+			return update_impl(static_cast<const void*>(&*begin), (end - begin) * sizeof(T));
+		}
+
+		template <typename T>
+		void update(const std::vector<T>& input)
+		{
+			return update_impl(static_cast<const void*>(input.data()), input.size() * sizeof(T));
+		}
+
+		template <typename T, size_t AN>
+		void update(const std::array<T, AN>& input)
+		{
+			return update_impl(static_cast<const void*>(input.data()), AN * sizeof(T));
+		}
+
+		template <typename T>
+		void update(const std::initializer_list<T>& input)
+		{
+			return update_impl(static_cast<const void*>(input.begin()), input.size() * sizeof(T));
+		}
+
+		hash_t<bit_mode> digest() const
+		{
+			return digest_impl();
+		}
+	};
+
+	using hash_state32_t = hash_state_t<32>;
+	using hash_state64_t = hash_state_t<64>;
+
+
+	/* *************************************
+	*  Hash streaming - xxhash3
+	***************************************/
+
+	template <size_t bit_mode>
+	class alignas(64) hash3_state_t 
+	{   
+		constexpr static int internal_buffer_size = 256;
+		constexpr static int internal_buffer_stripes = (internal_buffer_size / detail3::stripe_len);
+	
+		alignas(64) uint64_t acc[8];
+		alignas(64) uint8_t customSecret[detail3::secret_default_size];	/* used to store a custom secret generated from the seed. Makes state larger. Design might change */
+		alignas(64) uint8_t buffer[internal_buffer_size];
+		uint32_t bufferedSize = 0;
+		uint32_t nbStripesPerBlock = 0;
+		uint32_t nbStripesSoFar = 0;
+		uint32_t secretLimit = 0;
+		uint32_t reserved32 = 0;
+		uint32_t reserved32_2 = 0;
+		uint64_t totalLen = 0;
+		uint64_t seed = 0;
+		bool useSeed = false;
+		uint64_t reserved64 = 0;
+		const uint8_t* secret = nullptr;	/* note : there is some padding after, due to alignment on 64 bytes */
+
+
+		void consume_stripes(uint64_t* acc, uint32_t& nbStripesSoFar, size_t totalStripes, const uint8_t* input)
+		{
+			if (nbStripesPerBlock - nbStripesSoFar <= totalStripes)	/* need a scrambling operation */
+			{			
+				size_t const nbStripes = nbStripesPerBlock - nbStripesSoFar;
+
+				detail3::accumulate(acc, input, secret + (nbStripesSoFar * detail3::secret_consume_rate), nbStripes);
+				detail3::scramble_acc(acc, secret + secretLimit);
+				detail3::accumulate(acc, input + nbStripes * detail3::stripe_len, secret, totalStripes - nbStripes);
+				nbStripesSoFar = (uint32_t)(totalStripes - nbStripes);
+			}
+			else 
+			{
+				detail3::accumulate(acc, input, secret + (nbStripesSoFar * detail3::secret_consume_rate), totalStripes);
+				nbStripesSoFar += (uint32_t)totalStripes;
+			}
+		}
+
+		void update_impl(const void* input_, size_t len)
+		{
+			const uint8_t* input = static_cast<const uint8_t*>(input_);
+			const uint8_t* const bEnd = input + len;
+
+			totalLen += len;
+
+			if (bufferedSize + len <= internal_buffer_size) 
+			{	/* fill in tmp buffer */
+				memcpy(buffer + bufferedSize, input, len);
+				bufferedSize += (uint32_t)len;
+				return;
+			}
+			/* input now > XXH3_INTERNALBUFFER_SIZE */
+
+			if (bufferedSize > 0) 
+			{	/* some input within internal buffer: fill then consume it */
+				size_t const loadSize = internal_buffer_size - bufferedSize;
+
+				memcpy(buffer + bufferedSize, input, loadSize);
+				input += loadSize;
+				consume_stripes(acc, nbStripesSoFar, internal_buffer_stripes, buffer);
+				bufferedSize = 0;
+			}
+
+			/* consume input by full buffer quantities */
+			if (input + internal_buffer_size <= bEnd) 
+			{
+				const uint8_t* const limit = bEnd - internal_buffer_size;
+
+				do 
+				{
+					consume_stripes(acc, nbStripesSoFar, internal_buffer_stripes, input);
+					input += internal_buffer_size;
+				} 
+				while (input < limit);
+
+				memcpy(buffer + sizeof(buffer) - detail3::stripe_len, input - detail3::stripe_len, detail3::stripe_len);
+			}
+
+			if (input < bEnd) 
+			{	/* some remaining input input : buffer it */
+				memcpy(buffer, input, (size_t)(bEnd - input));
+				bufferedSize = (uint32_t)(bEnd - input);
+			}
+		}
+
+		void digest_long(uint64_t* acc_)
+		{
+			memcpy(acc_, acc, sizeof(acc));	/* digest locally, state remains unaltered, and can continue ingesting more input afterwards */
+
+			if (bufferedSize >= detail3::stripe_len) 
+			{
+				size_t const totalNbStripes = (bufferedSize - 1) / detail3::stripe_len;
+				uint32_t nbStripesSoFar = this->nbStripesSoFar;
+
+				consume_stripes(acc_, nbStripesSoFar, totalNbStripes, buffer);
+
+				/* one last partial stripe */
+				detail3::accumulate_512(acc_, buffer + bufferedSize - detail3::stripe_len, secret + secretLimit - detail3::secret_lastacc_start);
+			}
+			else 
+			{	/* bufferedSize < STRIPE_LEN */
+				/* one last stripe */
+				uint8_t lastStripe[detail3::stripe_len];
+				size_t const catchupSize = detail3::stripe_len - bufferedSize;
+				memcpy(lastStripe, buffer + sizeof(buffer) - catchupSize, catchupSize);
+				memcpy(lastStripe + catchupSize, buffer, bufferedSize);
+				detail3::accumulate_512(acc_, lastStripe, secret + secretLimit - detail3::secret_lastacc_start);
+			}
+		}
+
+		void reset_internal(uint64_t seed_reset, const void* secret_reset, size_t secret_size)
+		{
+			memset(this, 0, sizeof(*this));
+			memcpy(acc, detail3::init_acc.data(), sizeof(detail3::init_acc));
+			seed = seed_reset;
+			useSeed = (seed != 0);
+			secret = (const uint8_t*)secret_reset;
+			secretLimit = (uint32_t)(secret_size - detail3::stripe_len);
+			nbStripesPerBlock = secretLimit / detail3::secret_consume_rate;
+		}
+
+	public:
+
+		hash3_state_t operator=(hash3_state_t& other)
+		{
+			memcpy(this, &other, sizeof(hash3_state_t));
+		}
+
+		hash3_state_t(uint64_t seed = 0)
+		{
+			static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 streaming can only be used in 64 and 128 bit modes.");
+			reset(seed);
+		}
+
+		hash3_state_t(const void* secret, size_t secretSize, uint64_t seed = 0)
+		{
+			static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 streaming can only be used in 64 and 128 bit modes.");
+			reset(secret, secretSize, seed);
+		}
+
+		void reset(uint64_t seed = 0)
+		{ 
+			reset_internal(seed, detail3::default_secret, detail3::secret_default_size);
+			detail3::init_custom_secret(customSecret, seed);
+			secret = customSecret;
+		}
+
+		void reset(const void* secret, size_t secretSize, uint64_t seed = 0)
+		{
+			reset_internal(seed, secret, secretSize);
+			useSeed = true;
+		}
+
+		void update(const void* input, size_t len)
+		{
+			return update_impl(static_cast<const void*>(input), len);
+		}
+
+		template <typename T>
+		void update(const std::basic_string<T>& input)
+		{
+			return update_impl(static_cast<const void*>(input.data()), input.length() * sizeof(T));
+		}
+
+		template <typename ContiguousIterator>
+		void update(ContiguousIterator begin, ContiguousIterator end)
+		{
+			using T = typename std::decay_t<decltype(*end)>;
+			return update_impl(static_cast<const void*>(&*begin), (end - begin) * sizeof(T));
+		}
+
+		template <typename T>
+		void update(const std::vector<T>& input)
+		{
+			return update_impl(static_cast<const void*>(input.data()), input.size() * sizeof(T));
+		}
+
+		template <typename T, size_t AN>
+		void update(const std::array<T, AN>& input)
+		{
+			return update_impl(static_cast<const void*>(input.data()), AN * sizeof(T));
+		}
+
+		template <typename T>
+		void update(const std::initializer_list<T>& input)
+		{
+			return update_impl(static_cast<const void*>(input.begin()), input.size() * sizeof(T));
+		}
+
+		hash_t<bit_mode> digest()
+		{	
+			if (totalLen > detail3::midsize_max) 
+			{
+				alignas(128) hash64_t acc[detail3::acc_nb];
+				
+				digest_long(acc);
+
+				if constexpr (bit_mode == 64)
+				{
+					return detail3::merge_accs(acc, secret + detail3::secret_mergeaccs_start, (uint64_t)totalLen * detail::PRIME<64>(1));
+				}
+				else
+				{
+					uint64_t const low64 = detail3::merge_accs(acc, secret + detail3::secret_mergeaccs_start, (uint64_t)totalLen * detail::PRIME<64>(1));
+					uint64_t const high64 = detail3::merge_accs(acc, secret + secretLimit + detail3::stripe_len - sizeof(acc) - detail3::secret_mergeaccs_start, ~((uint64_t)totalLen * detail::PRIME<64>(2)));
+
+					return { low64, high64 };
+				}
+			}
+			else
+			{
+				return detail3::xxhash3_impl<bit_mode>(buffer, totalLen, seed, secret, secretLimit + detail3::stripe_len);
+			}
+		}
+	};
+
+	using hash3_state64_t = hash3_state_t<64>;
+	using hash3_state128_t = hash3_state_t<128>;
+}
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index f453fe8db..b3d62abed 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -10,7 +10,7 @@ f <- function(x) {
 
 print(f)
 
-rsh::rsh_compile(f, tier = "bytecode")
+rsh::rsh_compile(f, tier = "bytecode", opt_level = 3L)
 print(f)
 
 print(f(5))
diff --git a/proto/messages.proto b/proto/messages.proto
index 8270d6f73..d7345e5f2 100644
--- a/proto/messages.proto
+++ b/proto/messages.proto
@@ -36,7 +36,7 @@ message CompileRequest {
 }
 
 message CompileResponse {
-  bytes hash = 1;
+  uint64 hash = 1;
   Tier tier = 2;
   optional bytes code = 3;
   optional bytes constants = 4;
@@ -44,28 +44,28 @@ message CompileResponse {
 
 
 message Function {
-  bytes package_hash = 1;
+  uint64 package_hash = 1;
   string name = 2; //What if it is a closure passed to a HOF?
-  bytes hash = 3;
+  uint64 hash = 3;
   optional bytes body = 4;
   // what about the function parameters?
 }
 
 message FunctionRequest {
-  bytes hash = 1;
+  uint64 hash = 1;
 }
 
 message Environment {
-  map<string, bytes> values = 1;//Name of the variable to a hash of the value
+  map<string, uint64> values = 1;//Name of the variable to a hash of the value
 }
 
 
 message ValueRequest {
-  repeated bytes hash = 1;// We can batch and ask for several values
+  repeated uint64 hash = 1;// We can batch and ask for several values
 }
 
 message Value {
-  bytes hash = 1;
+  uint64 hash = 1;
   bytes value = 2;
 }
 message Values {
@@ -126,7 +126,7 @@ message TestFeedback {
 
 message CallFeedback {
   int64 n_calls = 1;
-  bytes callee_hash = 2;
+  uint64 callee_hash = 2;
 }
 
 message ValueFeedback {
@@ -165,11 +165,11 @@ message PackageSource {
 message Package {
   string name = 1;
   Version version = 2;
-  repeated bytes function_hashes = 4;
+  repeated uint64 function_hashes = 4;
   // What about package data? Maybe just the sysdata?
   optional PackageSource source = 5;//If none, it is a base package or a local package
 }
 
 message PackageRequest {
-  bytes hash = 1;
+  uint64 hash = 1;
 }
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 7a7de0b43..23d72278a 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -47,7 +47,13 @@ public void compile(
     int optimizationLevel = request.getOptimizationLevel(); // default is 0
     Messages.Context context = request.getContext(); // null if not provided
 
-    logger.info("Received request to compile function " + function.getName());
+    logger.info(
+        "Received request to compile function "
+            + function.getName()
+            + " at tier "
+            + tier
+            + " with optimization level "
+            + optimizationLevel);
 
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
diff --git a/server/src/main/proto/messages.proto b/server/src/main/proto/messages.proto
index 36f8917ec..d7345e5f2 100644
--- a/server/src/main/proto/messages.proto
+++ b/server/src/main/proto/messages.proto
@@ -1,8 +1,9 @@
 syntax = "proto3";
-package rsh.protocol;
 
 option java_package = "org.prlprg.server";
 
+package rsh.protocol;
+
 // Error handling
 // grpc already has a way to handle errors
 // Status message: https://grpc.github.io/grpc-java/javadoc/io/grpc/Status.html
@@ -35,36 +36,36 @@ message CompileRequest {
 }
 
 message CompileResponse {
-  bytes hash = 1;
+  uint64 hash = 1;
   Tier tier = 2;
   optional bytes code = 3;
-  optional bytes constant_pool = 4;
+  optional bytes constants = 4;
 }
 
 
 message Function {
-  bytes package_hash = 1;
+  uint64 package_hash = 1;
   string name = 2; //What if it is a closure passed to a HOF?
-  bytes hash = 3;
+  uint64 hash = 3;
   optional bytes body = 4;
   // what about the function parameters?
 }
 
 message FunctionRequest {
-  bytes hash = 1;
+  uint64 hash = 1;
 }
 
 message Environment {
-  map<string, bytes> values = 1;//Name of the variable to a hash of the value
+  map<string, uint64> values = 1;//Name of the variable to a hash of the value
 }
 
 
 message ValueRequest {
-  repeated bytes hash = 1;// We can batch and ask for several values
+  repeated uint64 hash = 1;// We can batch and ask for several values
 }
 
 message Value {
-  bytes hash = 1;
+  uint64 hash = 1;
   bytes value = 2;
 }
 message Values {
@@ -125,7 +126,7 @@ message TestFeedback {
 
 message CallFeedback {
   int64 n_calls = 1;
-  bytes callee_hash = 2;
+  uint64 callee_hash = 2;
 }
 
 message ValueFeedback {
@@ -164,11 +165,11 @@ message PackageSource {
 message Package {
   string name = 1;
   Version version = 2;
-  repeated bytes function_hashes = 4;
+  repeated uint64 function_hashes = 4;
   // What about package data? Maybe just the sysdata?
   optional PackageSource source = 5;//If none, it is a base package or a local package
 }
 
 message PackageRequest {
-  bytes hash = 1;
+  uint64 hash = 1;
 }
\ No newline at end of file
diff --git a/server/src/main/proto/routes.proto b/server/src/main/proto/routes.proto
index d66b1201e..5a3208f7d 100644
--- a/server/src/main/proto/routes.proto
+++ b/server/src/main/proto/routes.proto
@@ -2,10 +2,10 @@ syntax = "proto3";
 
 option java_package = "org.prlprg.server";
 
-package rsh.protocol;
-
 import "messages.proto";
 
+package rsh.protocol;
+
 // R sends requests to the compile server
 service CompileService {
   rpc Compile(CompileRequest) returns (CompileResponse) {}

From 5b460735991ecb9c09dee996586996d720afaac2 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 5 Sep 2024 11:13:23 +0200
Subject: [PATCH 47/80] Correctly support names for the optimized native code

---
 client/rsh/src/client.h     |  2 +-
 client/rsh/src/compiler.cpp | 13 ++++++-------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index f66d18c8b..408a81278 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -10,6 +10,7 @@
 #include <string>
 #include <vector>
 #include <variant>
+#include <unordered_map>
 #include <zmq.hpp>
 #include <grpc/grpc.h>
 #include <grpcpp/channel.h>
@@ -25,7 +26,6 @@ class Client {
   // For it to be able to access the client instance
   friend SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
 
-
 public:
   Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages);
 
diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index ce9bea02c..8187afbc8 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -42,25 +42,24 @@ static std::variant<protocol::CompileResponse, std::string> compile_closure(std:
   return client->remote_compile(name, closure_bytes, tier, opt_level);
 }
 
-static void *insert_into_jit(protocol::CompileResponse const &compiled_fun) {
+static void *insert_into_jit(const char* name, protocol::CompileResponse const &compiled_fun) {
   auto native_code = compiled_fun.code();
   GJIT->add_object(native_code);
-  // TODO: we should have a map hash to name of the function here
-  auto ptr = GJIT->lookup(compiled_fun.hash().c_str());
+  auto ptr = GJIT->lookup(name);
   if (!ptr) {
     Rf_error("Unable to find the function in the JIT");
   }
   return ptr;
 }
 
-static SEXP create_constant_pool(void *fun_ptr,
+static SEXP create_constant_pool(void *fun_ptr, const char* name, 
                                  protocol::CompileResponse const &compiled_fun) {
   auto pool = PROTECT(Rf_allocVector(VECSXP, 2));
 
   // create an external pointer to the JITed function with a finalizer
   // TODO: we should have a map hash to name of the function here
   auto p = R_MakeExternalPtr(fun_ptr, RSH_JIT_FUN_PTR,
-                             Rf_mkString(compiled_fun.hash().c_str()));
+                             Rf_mkString(name));
   R_RegisterCFinalizerEx(p, &jit_fun_destructor, FALSE);
 
   // slot 0: the pointer to the compiled function
@@ -147,8 +146,8 @@ SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp, SEXP tier_sxp) {
   if(tier == protocol::Tier::OPTIMIZED) {
     
 
-    auto fun_ptr = insert_into_jit(compiled_fun);
-    SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, compiled_fun));
+    auto fun_ptr = insert_into_jit(name_str, compiled_fun);
+    SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, name_str, compiled_fun));
     SEXP body = PROTECT(create_wrapper_body(closure, c_cp));
 
     // replace the closure body in place

From 35d8a14b425ce9ddc251dafe0618814623b6caa8 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 5 Sep 2024 11:35:47 +0200
Subject: [PATCH 48/80] Now with a cache

---
 client/rsh/src/client.cpp                     |  5 +-
 client/rsh/test6.R                            |  5 ++
 .../org/prlprg/server/CompileService.java     | 65 ++++++++++---------
 3 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 394e36b15..bb7777541 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -60,8 +60,9 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
   request.mutable_function()->set_name(name);
   request.mutable_function()->set_body(rds_closure.data(), rds_closure.size());
 
-  
-  auto hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
+  // should be xxh::xxhash3<64>(rds_closure.data(), rds_closure.size())
+  // but it seems that the serialization is not the same. Probably because we also get the environment with it?
+  auto hash = xxh::xxhash3<64>(name);
   request.mutable_function()->set_hash(hash);
 
   grpc::ClientContext context;
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index b3d62abed..103b088ce 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -15,4 +15,9 @@ print(f)
 
 print(f(5))
 
+stopifnot(f(5) == 52)
+
+# f should be in the compile cache now.
+rsh::rsh_compile(f, tier = "bytecode", opt_level = 3L)
+
 stopifnot(f(5) == 52)
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 23d72278a..7e05b7112 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -10,7 +10,6 @@
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
 import org.prlprg.bc.BCCompiler;
-import org.prlprg.bc.Bc;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.rds.RDSWriter;
 import org.prlprg.session.GNURSession;
@@ -25,8 +24,9 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   private @Nullable GNURSession session = null;
   // Cache for all values (including functions)
   private HashMap<ByteString, SEXP> cache = new HashMap<>();
-  // Cache for byte-code, only for functions
-  private HashMap<ByteString, Bc> bcCache = new HashMap<>();
+  // Cache for byte-code, only for functions. We keep the already serialized code in the cache
+  // not the Bc (or BcCodeSXP)
+  private HashMap<Long, ByteString> bcCache = new HashMap<>();
 
   // TODO: cache for native code, which should also include contexts
 
@@ -57,36 +57,43 @@ public void compile(
 
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
-    // TODO
-    if (function.hasBody()) {
+
+    // First see if we have the hash in the cache
+    var functionHash = function.getHash();
+    ByteString cached = bcCache.get(functionHash);
+    if (cached != null) {
+      logger.info("Found " + function.getName() + " in cache. No recompilation.");
       try {
-        ByteString serializedBc =
-            compileClosure(function.getBody(), optimizationLevel, responseObserver);
-        response.setCode(serializedBc);
+        response.setCode(cached);
       } catch (Exception e) {
-        // See
-        // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
-        // We could have more details using that:
-        // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
-        responseObserver.onError(
-            Status.INTERNAL
-                .withDescription(
-                    "Cannot compile function " + function.getName() + " ; " + e.getMessage())
-                .asRuntimeException());
+        throw new RuntimeException("Impossible to serialize the bytecode");
       }
     } else {
-      var functionHash = function.getHash();
-      Bc cached = bcCache.get(functionHash);
-      // Also cache the optimization level?
-      if (cached != null) {
-        // TODO:
-        // Serialize BcCode and ConstPool and set them in the response
-      } else {
-        // Ask the client for the body of the function
-
-        // Compile the function
-
-        // Add it to the code cache
+      logger.info("Compile function " + function.getName() + ": not found in cache.");
+      if (function.hasBody()) {
+        try {
+          ByteString serializedBc =
+              compileClosure(function.getBody(), optimizationLevel, responseObserver);
+          response.setCode(serializedBc);
+          // Add it to the cache
+          bcCache.put(functionHash, serializedBc);
+        } catch (Exception e) {
+          // See
+          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+          // We could have more details using that:
+          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
+          responseObserver.onError(
+              Status.INTERNAL
+                  .withDescription(
+                      "Cannot compile function " + function.getName() + " ; " + e.getMessage())
+                  .asRuntimeException());
+        }
+      } else { // No body
+        // we need to ask the client for the body
+        logger.info(
+            "No body sent with the request for function "
+                + function.getName()
+                + ". Cannot compile.");
       }
     }
 

From db1deb333fb51690a1b510e96e232bc56bfe34fa Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 5 Sep 2024 11:40:04 +0200
Subject: [PATCH 49/80] Adding optimisation level to the key for the bc cache

---
 client/rsh/test6.R                              |  5 +++++
 .../java/org/prlprg/server/CompileService.java  | 17 ++++++++++++-----
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index 103b088ce..b4815241d 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -20,4 +20,9 @@ stopifnot(f(5) == 52)
 # f should be in the compile cache now.
 rsh::rsh_compile(f, tier = "bytecode", opt_level = 3L)
 
+stopifnot(f(5) == 52)
+
+# another opt level so it should be recompiled
+rsh::rsh_compile(f, tier = "bytecode", opt_level = 2L)
+
 stopifnot(f(5) == 52)
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 7e05b7112..cfcfa49c1 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -17,6 +17,7 @@
 import org.prlprg.sexp.CloSXP;
 import org.prlprg.sexp.SEXP;
 import org.prlprg.sexp.SEXPs;
+import org.prlprg.util.Pair;
 
 class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   private static final Logger logger = Logger.getLogger(CompileServer.class.getName());
@@ -26,7 +27,8 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   private HashMap<ByteString, SEXP> cache = new HashMap<>();
   // Cache for byte-code, only for functions. We keep the already serialized code in the cache
   // not the Bc (or BcCodeSXP)
-  private HashMap<Long, ByteString> bcCache = new HashMap<>();
+  // Key is (hash, optimisationLevel)
+  private HashMap<Pair<Long, Integer>, ByteString> bcCache = new HashMap<>();
 
   // TODO: cache for native code, which should also include contexts
 
@@ -59,8 +61,8 @@ public void compile(
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
 
     // First see if we have the hash in the cache
-    var functionHash = function.getHash();
-    ByteString cached = bcCache.get(functionHash);
+    var bcKey = Pair.of(function.getHash(), optimizationLevel);
+    ByteString cached = bcCache.get(bcKey);
     if (cached != null) {
       logger.info("Found " + function.getName() + " in cache. No recompilation.");
       try {
@@ -69,14 +71,19 @@ public void compile(
         throw new RuntimeException("Impossible to serialize the bytecode");
       }
     } else {
-      logger.info("Compile function " + function.getName() + ": not found in cache.");
+      logger.info(
+          "Compile function "
+              + function.getName()
+              + "with optimisation level "
+              + optimizationLevel
+              + ": not found in cache.");
       if (function.hasBody()) {
         try {
           ByteString serializedBc =
               compileClosure(function.getBody(), optimizationLevel, responseObserver);
           response.setCode(serializedBc);
           // Add it to the cache
-          bcCache.put(functionHash, serializedBc);
+          bcCache.put(bcKey, serializedBc);
         } catch (Exception e) {
           // See
           // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java

From 718e704bcf752d07c8d85d474e04912ebcdea368 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 5 Sep 2024 15:39:28 +0200
Subject: [PATCH 50/80] Caching: does not recompile if body (and enclosure) is
 not changed.

Works if function is renamed.
---
 client/rsh/src/client.cpp                     | 22 +++++++++++++++----
 client/rsh/src/client.h                       |  5 +++++
 client/rsh/src/compiler.cpp                   |  4 ++++
 client/rsh/test6.R                            | 11 +++++++++-
 .../org/prlprg/server/CompileService.java     |  2 +-
 5 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index bb7777541..74a199b9b 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -1,5 +1,6 @@
 #include "client.h"
 #include "xxhash.hpp"
+#include "serialize.h"
 
 #include <grpc/grpc.h>
 #include <grpcpp/channel.h>
@@ -60,10 +61,17 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
   request.mutable_function()->set_name(name);
   request.mutable_function()->set_body(rds_closure.data(), rds_closure.size());
 
-  // should be xxh::xxhash3<64>(rds_closure.data(), rds_closure.size())
-  // but it seems that the serialization is not the same. Probably because we also get the environment with it?
-  auto hash = xxh::xxhash3<64>(name);
-  request.mutable_function()->set_hash(hash);
+  // We replace the body of a function with its compiled version so it would not make 
+  //sense to compute its hash again, except if its body has changed.
+  auto hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
+  Rprintf("Hash: %lu ; compiled hash: %lu\n", hash, compiled_functions[name].second);
+  if(compiled_functions.find(name) != compiled_functions.end() && compiled_functions[name].second == hash) {
+    request.mutable_function()->set_hash(compiled_functions[name].first);
+  }
+  else {
+    request.mutable_function()->set_hash(hash);
+    compiled_functions[name] = std::make_pair(hash, 0);
+  }
 
   grpc::ClientContext context;
   CompileResponse response;
@@ -127,4 +135,10 @@ SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
   return R_NilValue;
 }
 
+void Client::mark_compiled_function(const std::string& name, SEXP closure) {
+  auto bytes = rsh::serialize(closure);
+  Client::get_client()->compiled_functions[name].second = xxh::xxhash3<64>(bytes);
+}
+
+
 } // namespace rsh
diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index 408a81278..750bab5d0 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -26,6 +26,10 @@ class Client {
   // For it to be able to access the client instance
   friend SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
 
+  // Remember the compiled functions with their hash both when 
+  // they are not yet compiled, and when they are.
+  std::unordered_map<std::string, std::pair<uint64_t, uint64_t>> compiled_functions;
+
 public:
   Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages);
 
@@ -36,6 +40,7 @@ class Client {
 
   static SEXP make_client(SEXP address, SEXP port, SEXP installed_packages);
   static Client* get_client();
+  static void mark_compiled_function(const std::string& name, SEXP closure);
 };
 
 SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 8187afbc8..858715941 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -168,6 +168,10 @@ SEXP compile_fun(SEXP closure, SEXP name, SEXP opt_level_sxp, SEXP tier_sxp) {
     UNPROTECT(1);
   }
 
+  // To be able to see if the body of a closure is the result of a JIT compilation
+  // TODO: don't mark it again if we know that the compile server is sending the same code again.
+  Client::mark_compiled_function(name_str, closure);
+
   return closure;
 }
 
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index b4815241d..75b635ef5 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -25,4 +25,13 @@ stopifnot(f(5) == 52)
 # another opt level so it should be recompiled
 rsh::rsh_compile(f, tier = "bytecode", opt_level = 2L)
 
-stopifnot(f(5) == 52)
\ No newline at end of file
+stopifnot(f(5) == 52)
+
+f <- function(x) {
+    x + 3
+}
+
+# body changed so it should be recompiled
+rsh::rsh_compile(f, tier = "bytecode", opt_level = 2L)
+
+stopifnot(f(5) == 8)
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index cfcfa49c1..79c9db918 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -74,7 +74,7 @@ public void compile(
       logger.info(
           "Compile function "
               + function.getName()
-              + "with optimisation level "
+              + " with optimisation level "
               + optimizationLevel
               + ": not found in cache.");
       if (function.hasBody()) {

From 48db12c7cd1c1f4cf370ba9be23e0d9ffdd84190 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 5 Sep 2024 15:59:05 +0200
Subject: [PATCH 51/80] Fix some paths to have the package test pass

---
 client/rsh/src/client.cpp                     |  1 -
 .../org/prlprg/rsession/GNURSessionTest.java  | 22 +++++++++++--------
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 74a199b9b..3b52656f8 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -64,7 +64,6 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
   // We replace the body of a function with its compiled version so it would not make 
   //sense to compute its hash again, except if its body has changed.
   auto hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
-  Rprintf("Hash: %lu ; compiled hash: %lu\n", hash, compiled_functions[name].second);
   if(compiled_functions.find(name) != compiled_functions.end() && compiled_functions[name].second == hash) {
     request.mutable_function()->set_hash(compiled_functions[name].first);
   }
diff --git a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index 43b659f1b..b229d7c67 100644
--- a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -14,9 +14,9 @@ public class GNURSessionTest {
 
   @Test
   public void testReadPackageDatabase() throws IOException {
-    var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "/usr/local/lib/R/library/";
-    //    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
+    var r_dir = Path.of("/usr/lib/R/");
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
     session.loadPackage("yaml", "2.3.10");
@@ -28,7 +28,7 @@ public void testReadPackageDatabase() throws IOException {
 
   @Test
   public void testLoadBase() throws IOException {
-    var p = Path.of("/usr/local/lib/R/");
+    var p = Path.of("/usr/lib/R/");
     var session = new GNURSession(RVersion.LATEST_AWARE, p, null);
     session.loadBase();
 
@@ -38,7 +38,8 @@ public void testLoadBase() throws IOException {
   @Test
   public void testVersionMismatch() {
     var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "/usr/local/lib/R/library/";
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
     Assertions.assertThrows(
@@ -51,7 +52,8 @@ public void testVersionMismatch() {
   @Test
   public void testLoadNonInstalledPackage() throws IOException, InterruptedException {
     var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "/usr/local/lib/R/library/";
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
     // Assuming "nonexistentpkg" is not installed
@@ -64,8 +66,9 @@ public void testLoadNonInstalledPackage() throws IOException, InterruptedExcepti
 
   @Test
   public void testRetrieveNamespaceAfterLoadingPackage() throws IOException {
-    var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "/usr/local/lib/R/library/";
+    var r_dir = Path.of("/usr/lib/R/");
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
     session.loadPackage("yaml", "2.3.10");
@@ -78,7 +81,8 @@ public void testRetrieveNamespaceAfterLoadingPackage() throws IOException {
   @Test
   public void testMissingDescriptionFile() {
     var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "/usr/local/lib/R/library/";
+    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
+    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
 
     // Assuming "pkgwithnomissingdesc" has no DESCRIPTION file

From 73d82fb6be484980bda3ad7f2b3219559a5fd3fa Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 5 Sep 2024 16:03:33 +0200
Subject: [PATCH 52/80] Remove ZeroMQ

---
 client/rsh/{src => inst}/xxhash.hpp |    0
 client/rsh/inst/zmq.hpp             | 2561 ---------------------------
 client/rsh/inst/zmq_addon.hpp       |  753 --------
 client/rsh/src/client.h             |    1 -
 4 files changed, 3315 deletions(-)
 rename client/rsh/{src => inst}/xxhash.hpp (100%)
 delete mode 100644 client/rsh/inst/zmq.hpp
 delete mode 100644 client/rsh/inst/zmq_addon.hpp

diff --git a/client/rsh/src/xxhash.hpp b/client/rsh/inst/xxhash.hpp
similarity index 100%
rename from client/rsh/src/xxhash.hpp
rename to client/rsh/inst/xxhash.hpp
diff --git a/client/rsh/inst/zmq.hpp b/client/rsh/inst/zmq.hpp
deleted file mode 100644
index 8dee60e35..000000000
--- a/client/rsh/inst/zmq.hpp
+++ /dev/null
@@ -1,2561 +0,0 @@
-/*
-    Copyright (c) 2016-2017 ZeroMQ community
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    Copyright (c) 2011 Botond Ballo
-    Copyright (c) 2007-2009 iMatix Corporation
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to
-    deal in the Software without restriction, including without limitation the
-    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-    sell copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-*/
-
-#ifndef __ZMQ_HPP_INCLUDED__
-#define __ZMQ_HPP_INCLUDED__
-
-#ifdef _WIN32
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#endif
-
-// included here for _HAS_CXX* macros
-#include <zmq.h>
-
-#if defined(_MSVC_LANG)
-#define CPPZMQ_LANG _MSVC_LANG
-#else
-#define CPPZMQ_LANG __cplusplus
-#endif
-// overwrite if specific language macros indicate higher version
-#if defined(_HAS_CXX14) && _HAS_CXX14 && CPPZMQ_LANG < 201402L
-#undef CPPZMQ_LANG
-#define CPPZMQ_LANG 201402L
-#endif
-#if defined(_HAS_CXX17) && _HAS_CXX17 && CPPZMQ_LANG < 201703L
-#undef CPPZMQ_LANG
-#define CPPZMQ_LANG 201703L
-#endif
-
-// macros defined if has a specific standard or greater
-#if CPPZMQ_LANG >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
-#define ZMQ_CPP11
-#endif
-#if CPPZMQ_LANG >= 201402L
-#define ZMQ_CPP14
-#endif
-#if CPPZMQ_LANG >= 201703L
-#define ZMQ_CPP17
-#endif
-
-#if defined(ZMQ_CPP14) && !defined(_MSC_VER)
-#define ZMQ_DEPRECATED(msg) [[deprecated(msg)]]
-#elif defined(_MSC_VER)
-#define ZMQ_DEPRECATED(msg) __declspec(deprecated(msg))
-#elif defined(__GNUC__)
-#define ZMQ_DEPRECATED(msg) __attribute__((deprecated(msg)))
-#else
-#define ZMQ_DEPRECATED(msg)
-#endif
-
-#if defined(ZMQ_CPP17)
-#define ZMQ_NODISCARD [[nodiscard]]
-#else
-#define ZMQ_NODISCARD
-#endif
-
-#if defined(ZMQ_CPP11)
-#define ZMQ_NOTHROW noexcept
-#define ZMQ_EXPLICIT explicit
-#define ZMQ_OVERRIDE override
-#define ZMQ_NULLPTR nullptr
-#define ZMQ_CONSTEXPR_FN constexpr
-#define ZMQ_CONSTEXPR_VAR constexpr
-#define ZMQ_CPP11_DEPRECATED(msg) ZMQ_DEPRECATED(msg)
-#else
-#define ZMQ_NOTHROW throw()
-#define ZMQ_EXPLICIT
-#define ZMQ_OVERRIDE
-#define ZMQ_NULLPTR 0
-#define ZMQ_CONSTEXPR_FN
-#define ZMQ_CONSTEXPR_VAR const
-#define ZMQ_CPP11_DEPRECATED(msg)
-#endif
-#if defined(ZMQ_CPP14) && (!defined(_MSC_VER) || _MSC_VER > 1900) && (!defined(__GNUC__) || __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3))
-#define ZMQ_EXTENDED_CONSTEXPR
-#endif
-#if defined(ZMQ_CPP17)
-#define ZMQ_INLINE_VAR inline
-#define ZMQ_CONSTEXPR_IF constexpr
-#else
-#define ZMQ_INLINE_VAR
-#define ZMQ_CONSTEXPR_IF
-#endif
-
-#include <cassert>
-#include <cstring>
-
-#include <algorithm>
-#include <exception>
-#include <iomanip>
-#include <sstream>
-#include <string>
-#include <vector>
-#ifdef ZMQ_CPP11
-#include <array>
-#include <chrono>
-#include <tuple>
-#include <memory>
-#endif
-
-#if defined(__has_include) && defined(ZMQ_CPP17)
-#define CPPZMQ_HAS_INCLUDE_CPP17(X) __has_include(X)
-#else
-#define CPPZMQ_HAS_INCLUDE_CPP17(X) 0
-#endif
-
-#if CPPZMQ_HAS_INCLUDE_CPP17(<optional>) && !defined(CPPZMQ_HAS_OPTIONAL)
-#define CPPZMQ_HAS_OPTIONAL 1
-#endif
-#ifndef CPPZMQ_HAS_OPTIONAL
-#define CPPZMQ_HAS_OPTIONAL 0
-#elif CPPZMQ_HAS_OPTIONAL
-#include <optional>
-#endif
-
-#if CPPZMQ_HAS_INCLUDE_CPP17(<string_view>) && !defined(CPPZMQ_HAS_STRING_VIEW)
-#define CPPZMQ_HAS_STRING_VIEW 1
-#endif
-#ifndef CPPZMQ_HAS_STRING_VIEW
-#define CPPZMQ_HAS_STRING_VIEW 0
-#elif CPPZMQ_HAS_STRING_VIEW
-#include <string_view>
-#endif
-
-/*  Version macros for compile-time API version detection                     */
-#define CPPZMQ_VERSION_MAJOR 4
-#define CPPZMQ_VERSION_MINOR 10
-#define CPPZMQ_VERSION_PATCH 0
-
-#define CPPZMQ_VERSION                                                              \
-    ZMQ_MAKE_VERSION(CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR,                    \
-                     CPPZMQ_VERSION_PATCH)
-
-//  Detect whether the compiler supports C++11 rvalue references.
-#if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2))   \
-     && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#define ZMQ_HAS_RVALUE_REFS
-#define ZMQ_DELETED_FUNCTION = delete
-#elif defined(__clang__)
-#if __has_feature(cxx_rvalue_references)
-#define ZMQ_HAS_RVALUE_REFS
-#endif
-
-#if __has_feature(cxx_deleted_functions)
-#define ZMQ_DELETED_FUNCTION = delete
-#else
-#define ZMQ_DELETED_FUNCTION
-#endif
-#elif defined(_MSC_VER) && (_MSC_VER >= 1900)
-#define ZMQ_HAS_RVALUE_REFS
-#define ZMQ_DELETED_FUNCTION = delete
-#elif defined(_MSC_VER) && (_MSC_VER >= 1600)
-#define ZMQ_HAS_RVALUE_REFS
-#define ZMQ_DELETED_FUNCTION
-#else
-#define ZMQ_DELETED_FUNCTION
-#endif
-
-#if defined(ZMQ_CPP11) && !defined(__llvm__) && !defined(__INTEL_COMPILER)          \
-  && defined(__GNUC__) && __GNUC__ < 5
-#define ZMQ_CPP11_PARTIAL
-#elif defined(__GLIBCXX__) && __GLIBCXX__ < 20160805
-//the date here is the last date of gcc 4.9.4, which
-// effectively means libstdc++ from gcc 5.5 and higher won't trigger this branch
-#define ZMQ_CPP11_PARTIAL
-#endif
-
-#ifdef ZMQ_CPP11
-#ifdef ZMQ_CPP11_PARTIAL
-#define ZMQ_IS_TRIVIALLY_COPYABLE(T) __has_trivial_copy(T)
-#else
-#include <type_traits>
-#define ZMQ_IS_TRIVIALLY_COPYABLE(T) std::is_trivially_copyable<T>::value
-#endif
-#endif
-
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 3, 0)
-#define ZMQ_NEW_MONITOR_EVENT_LAYOUT
-#endif
-
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
-#define ZMQ_HAS_PROXY_STEERABLE
-/*  Socket event data  */
-typedef struct
-{
-    uint16_t event; // id of the event as bitfield
-    int32_t value;  // value is either error code, fd or reconnect interval
-} zmq_event_t;
-#endif
-
-// Avoid using deprecated message receive function when possible
-#if ZMQ_VERSION < ZMQ_MAKE_VERSION(3, 2, 0)
-#define zmq_msg_recv(msg, socket, flags) zmq_recvmsg(socket, msg, flags)
-#endif
-
-
-// In order to prevent unused variable warnings when building in non-debug
-// mode use this macro to make assertions.
-#ifndef NDEBUG
-#define ZMQ_ASSERT(expression) assert(expression)
-#else
-#define ZMQ_ASSERT(expression) (void) (expression)
-#endif
-
-namespace zmq
-{
-#ifdef ZMQ_CPP11
-namespace detail
-{
-namespace ranges
-{
-using std::begin;
-using std::end;
-template<class T> auto begin(T &&r) -> decltype(begin(std::forward<T>(r)))
-{
-    return begin(std::forward<T>(r));
-}
-template<class T> auto end(T &&r) -> decltype(end(std::forward<T>(r)))
-{
-    return end(std::forward<T>(r));
-}
-} // namespace ranges
-
-template<class T> using void_t = void;
-
-template<class Iter>
-using iter_value_t = typename std::iterator_traits<Iter>::value_type;
-
-template<class Range>
-using range_iter_t = decltype(
-  ranges::begin(std::declval<typename std::remove_reference<Range>::type &>()));
-
-template<class Range> using range_value_t = iter_value_t<range_iter_t<Range>>;
-
-template<class T, class = void> struct is_range : std::false_type
-{
-};
-
-template<class T>
-struct is_range<
-  T,
-  void_t<decltype(
-    ranges::begin(std::declval<typename std::remove_reference<T>::type &>())
-    == ranges::end(std::declval<typename std::remove_reference<T>::type &>()))>>
-    : std::true_type
-{
-};
-
-} // namespace detail
-#endif
-
-typedef zmq_free_fn free_fn;
-typedef zmq_pollitem_t pollitem_t;
-
-// duplicate definition from libzmq 4.3.3
-#if defined _WIN32
-#if defined _WIN64
-typedef unsigned __int64 fd_t;
-#else
-typedef unsigned int fd_t;
-#endif
-#else
-typedef int fd_t;
-#endif
-
-class error_t : public std::exception
-{
-  public:
-    error_t() ZMQ_NOTHROW : errnum(zmq_errno()) {}
-    explicit error_t(int err) ZMQ_NOTHROW : errnum(err) {}
-    virtual const char *what() const ZMQ_NOTHROW ZMQ_OVERRIDE
-    {
-        return zmq_strerror(errnum);
-    }
-    int num() const ZMQ_NOTHROW { return errnum; }
-
-  private:
-    int errnum;
-};
-
-namespace detail {
-inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_)
-{
-    int rc = zmq_poll(items_, static_cast<int>(nitems_), timeout_);
-    // if (rc < 0)
-    //     throw error_t();
-    return rc;
-}
-}
-
-#ifdef ZMQ_CPP11
-ZMQ_DEPRECATED("from 4.8.0, use poll taking std::chrono::duration instead of long")
-inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_)
-#else
-inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_ = -1)
-#endif
-{
-    return detail::poll(items_, nitems_, timeout_);
-}
-
-ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
-inline int poll(zmq_pollitem_t const *items_, size_t nitems_, long timeout_ = -1)
-{
-    return detail::poll(const_cast<zmq_pollitem_t *>(items_), nitems_, timeout_);
-}
-
-#ifdef ZMQ_CPP11
-ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
-inline int
-poll(zmq_pollitem_t const *items, size_t nitems, std::chrono::milliseconds timeout)
-{
-    return detail::poll(const_cast<zmq_pollitem_t *>(items), nitems,
-                static_cast<long>(timeout.count()));
-}
-
-ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
-inline int poll(std::vector<zmq_pollitem_t> const &items,
-                std::chrono::milliseconds timeout)
-{
-    return detail::poll(const_cast<zmq_pollitem_t *>(items.data()), items.size(),
-                static_cast<long>(timeout.count()));
-}
-
-ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
-inline int poll(std::vector<zmq_pollitem_t> const &items, long timeout_ = -1)
-{
-    return detail::poll(const_cast<zmq_pollitem_t *>(items.data()), items.size(), timeout_);
-}
-
-inline int
-poll(zmq_pollitem_t *items, size_t nitems, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
-{
-    return detail::poll(items, nitems, static_cast<long>(timeout.count()));
-}
-
-inline int poll(std::vector<zmq_pollitem_t> &items,
-                std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
-{
-    return detail::poll(items.data(), items.size(), static_cast<long>(timeout.count()));
-}
-
-ZMQ_DEPRECATED("from 4.3.1, use poll taking std::chrono::duration instead of long")
-inline int poll(std::vector<zmq_pollitem_t> &items, long timeout_)
-{
-    return detail::poll(items.data(), items.size(), timeout_);
-}
-
-template<std::size_t SIZE>
-inline int poll(std::array<zmq_pollitem_t, SIZE> &items,
-                std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
-{
-    return detail::poll(items.data(), items.size(), static_cast<long>(timeout.count()));
-}
-#endif
-
-
-inline void version(int *major_, int *minor_, int *patch_)
-{
-    zmq_version(major_, minor_, patch_);
-}
-
-#ifdef ZMQ_CPP11
-inline std::tuple<int, int, int> version()
-{
-    std::tuple<int, int, int> v;
-    zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v));
-    return v;
-}
-
-#if !defined(ZMQ_CPP11_PARTIAL)
-namespace detail
-{
-template<class T> struct is_char_type
-{
-    // true if character type for string literals in C++11
-    static constexpr bool value =
-      std::is_same<T, char>::value || std::is_same<T, wchar_t>::value
-      || std::is_same<T, char16_t>::value || std::is_same<T, char32_t>::value;
-};
-}
-#endif
-
-#endif
-
-class message_t
-{
-  public:
-    message_t() ZMQ_NOTHROW
-    {
-        int rc = zmq_msg_init(&msg);
-        ZMQ_ASSERT(rc == 0);
-    }
-
-    explicit message_t(size_t size_)
-    {
-        int rc = zmq_msg_init_size(&msg, size_);
-        if (rc != 0)
-            throw error_t();
-    }
-
-    template<class ForwardIter> message_t(ForwardIter first, ForwardIter last)
-    {
-        typedef typename std::iterator_traits<ForwardIter>::value_type value_t;
-
-        assert(std::distance(first, last) >= 0);
-        size_t const size_ =
-          static_cast<size_t>(std::distance(first, last)) * sizeof(value_t);
-        int const rc = zmq_msg_init_size(&msg, size_);
-        if (rc != 0)
-            throw error_t();
-        std::copy(first, last, data<value_t>());
-    }
-
-    message_t(const void *data_, size_t size_)
-    {
-        int rc = zmq_msg_init_size(&msg, size_);
-        if (rc != 0)
-            throw error_t();
-        if (size_) {
-            // this constructor allows (nullptr, 0),
-            // memcpy with a null pointer is UB
-            memcpy(data(), data_, size_);
-        }
-    }
-
-    message_t(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR)
-    {
-        int rc = zmq_msg_init_data(&msg, data_, size_, ffn_, hint_);
-        if (rc != 0)
-            throw error_t();
-    }
-
-    // overload set of string-like types and generic containers
-#if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
-    // NOTE this constructor will include the null terminator
-    // when called with a string literal.
-    // An overload taking const char* can not be added because
-    // it would be preferred over this function and break compatiblity.
-    template<
-      class Char,
-      size_t N,
-      typename = typename std::enable_if<detail::is_char_type<Char>::value>::type>
-    ZMQ_DEPRECATED("from 4.7.0, use constructors taking iterators, (pointer, size) "
-                   "or strings instead")
-    explicit message_t(const Char (&data)[N]) :
-        message_t(detail::ranges::begin(data), detail::ranges::end(data))
-    {
-    }
-
-    template<class Range,
-             typename = typename std::enable_if<
-               detail::is_range<Range>::value
-               && ZMQ_IS_TRIVIALLY_COPYABLE(detail::range_value_t<Range>)
-               && !detail::is_char_type<detail::range_value_t<Range>>::value
-               && !std::is_same<Range, message_t>::value>::type>
-    explicit message_t(const Range &rng) :
-        message_t(detail::ranges::begin(rng), detail::ranges::end(rng))
-    {
-    }
-
-    explicit message_t(const std::string &str) : message_t(str.data(), str.size()) {}
-
-#if CPPZMQ_HAS_STRING_VIEW
-    explicit message_t(std::string_view str) : message_t(str.data(), str.size()) {}
-#endif
-
-#endif
-
-#ifdef ZMQ_HAS_RVALUE_REFS
-    message_t(message_t &&rhs) ZMQ_NOTHROW : msg(rhs.msg)
-    {
-        int rc = zmq_msg_init(&rhs.msg);
-        ZMQ_ASSERT(rc == 0);
-    }
-
-    message_t &operator=(message_t &&rhs) ZMQ_NOTHROW
-    {
-        std::swap(msg, rhs.msg);
-        return *this;
-    }
-#endif
-
-    ~message_t() ZMQ_NOTHROW
-    {
-        int rc = zmq_msg_close(&msg);
-        ZMQ_ASSERT(rc == 0);
-    }
-
-    void rebuild()
-    {
-        int rc = zmq_msg_close(&msg);
-        if (rc != 0)
-            throw error_t();
-        rc = zmq_msg_init(&msg);
-        ZMQ_ASSERT(rc == 0);
-    }
-
-    void rebuild(size_t size_)
-    {
-        int rc = zmq_msg_close(&msg);
-        if (rc != 0)
-            throw error_t();
-        rc = zmq_msg_init_size(&msg, size_);
-        if (rc != 0)
-            throw error_t();
-    }
-
-    void rebuild(const void *data_, size_t size_)
-    {
-        int rc = zmq_msg_close(&msg);
-        if (rc != 0)
-            throw error_t();
-        rc = zmq_msg_init_size(&msg, size_);
-        if (rc != 0)
-            throw error_t();
-        memcpy(data(), data_, size_);
-    }
-    
-    void rebuild(const std::string &str)
-    {
-        rebuild(str.data(), str.size());
-    }
-
-    void rebuild(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR)
-    {
-        int rc = zmq_msg_close(&msg);
-        if (rc != 0)
-            throw error_t();
-        rc = zmq_msg_init_data(&msg, data_, size_, ffn_, hint_);
-        if (rc != 0)
-            throw error_t();
-    }
-
-    ZMQ_DEPRECATED("from 4.3.1, use move taking non-const reference instead")
-    void move(message_t const *msg_)
-    {
-        int rc = zmq_msg_move(&msg, const_cast<zmq_msg_t *>(msg_->handle()));
-        if (rc != 0)
-            throw error_t();
-    }
-
-    void move(message_t &msg_)
-    {
-        int rc = zmq_msg_move(&msg, msg_.handle());
-        if (rc != 0)
-            throw error_t();
-    }
-
-    ZMQ_DEPRECATED("from 4.3.1, use copy taking non-const reference instead")
-    void copy(message_t const *msg_)
-    {
-        int rc = zmq_msg_copy(&msg, const_cast<zmq_msg_t *>(msg_->handle()));
-        if (rc != 0)
-            throw error_t();
-    }
-
-    void copy(message_t &msg_)
-    {
-        int rc = zmq_msg_copy(&msg, msg_.handle());
-        if (rc != 0)
-            throw error_t();
-    }
-
-    bool more() const ZMQ_NOTHROW
-    {
-        int rc = zmq_msg_more(const_cast<zmq_msg_t *>(&msg));
-        return rc != 0;
-    }
-
-    void *data() ZMQ_NOTHROW { return zmq_msg_data(&msg); }
-
-    const void *data() const ZMQ_NOTHROW
-    {
-        return zmq_msg_data(const_cast<zmq_msg_t *>(&msg));
-    }
-
-    size_t size() const ZMQ_NOTHROW
-    {
-        return zmq_msg_size(const_cast<zmq_msg_t *>(&msg));
-    }
-
-    ZMQ_NODISCARD bool empty() const ZMQ_NOTHROW { return size() == 0u; }
-
-    template<typename T> T *data() ZMQ_NOTHROW { return static_cast<T *>(data()); }
-
-  template <typename T> T const *data() const ZMQ_NOTHROW {
-    return static_cast<T const *>(data());
-  }
-
-  ZMQ_DEPRECATED("from 4.3.0, use operator== instead")
-  bool equal(const message_t *other) const ZMQ_NOTHROW {
-    return *this == *other;
-  }
-
-  bool operator==(const message_t &other) const ZMQ_NOTHROW {
-    const size_t my_size = size();
-    return my_size == other.size() &&
-           0 == memcmp(data(), other.data(), my_size);
-  }
-
-  bool operator!=(const message_t &other) const ZMQ_NOTHROW {
-    return !(*this == other);
-  }
-
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 2, 0)
-  int get(int property_) {
-    int value = zmq_msg_get(&msg, property_);
-    if (value == -1)
-      throw error_t();
-    return value;
-  }
-#endif
-
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
-  const char *gets(const char *property_) {
-    const char *value = zmq_msg_gets(&msg, property_);
-    if (value == ZMQ_NULLPTR)
-      throw error_t();
-    return value;
-  }
-#endif
-
-#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
-  uint32_t routing_id() const {
-    return zmq_msg_routing_id(const_cast<zmq_msg_t *>(&msg));
-  }
-
-  void set_routing_id(uint32_t routing_id) {
-    int rc = zmq_msg_set_routing_id(&msg, routing_id);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  const char *group() const {
-    return zmq_msg_group(const_cast<zmq_msg_t *>(&msg));
-  }
-
-  void set_group(const char *group) {
-    int rc = zmq_msg_set_group(&msg, group);
-    if (rc != 0)
-      throw error_t();
-  }
-#endif
-
-  // interpret message content as a string
-  std::string to_string() const {
-    return std::string(static_cast<const char *>(data()), size());
-  }
-#if CPPZMQ_HAS_STRING_VIEW
-  // interpret message content as a string
-  std::string_view to_string_view() const noexcept {
-    return std::string_view(static_cast<const char *>(data()), size());
-  }
-#endif
-
-  /** Dump content to string for debugging.
-   *   Ascii chars are readable, the rest is printed as hex.
-   *   Probably ridiculously slow.
-   *   Use to_string() or to_string_view() for
-   *   interpreting the message as a string.
-   */
-  std::string str() const {
-    // Partly mutuated from the same method in zmq::multipart_t
-    std::stringstream os;
-
-    const unsigned char *msg_data = this->data<unsigned char>();
-    unsigned char byte;
-    size_t size = this->size();
-    int is_ascii[2] = {0, 0};
-
-    os << "zmq::message_t [size " << std::dec << std::setw(3)
-       << std::setfill('0') << size << "] (";
-    // Totally arbitrary
-    if (size >= 1000) {
-      os << "... too big to print)";
-    } else {
-      while (size--) {
-        byte = *msg_data++;
-
-        is_ascii[1] = (byte >= 32 && byte < 127);
-        if (is_ascii[1] != is_ascii[0])
-          os << " "; // Separate text/non text
-
-        if (is_ascii[1]) {
-          os << byte;
-        } else {
-          os << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
-             << static_cast<short>(byte);
-        }
-        is_ascii[0] = is_ascii[1];
-      }
-      os << ")";
-    }
-    return os.str();
-  }
-
-  void swap(message_t &other) ZMQ_NOTHROW {
-    // this assumes zmq::msg_t from libzmq is trivially relocatable
-    std::swap(msg, other.msg);
-  }
-
-  ZMQ_NODISCARD zmq_msg_t *handle() ZMQ_NOTHROW { return &msg; }
-  ZMQ_NODISCARD const zmq_msg_t *handle() const ZMQ_NOTHROW { return &msg; }
-
-private:
-  //  The underlying message
-  zmq_msg_t msg;
-
-  //  Disable implicit message copying, so that users won't use shared
-  //  messages (less efficient) without being aware of the fact.
-  message_t(const message_t &) ZMQ_DELETED_FUNCTION;
-  void operator=(const message_t &) ZMQ_DELETED_FUNCTION;
-};
-
-inline void swap(message_t &a, message_t &b) ZMQ_NOTHROW { a.swap(b); }
-
-#ifdef ZMQ_CPP11
-enum class ctxopt {
-#ifdef ZMQ_BLOCKY
-  blocky = ZMQ_BLOCKY,
-#endif
-#ifdef ZMQ_IO_THREADS
-  io_threads = ZMQ_IO_THREADS,
-#endif
-#ifdef ZMQ_THREAD_SCHED_POLICY
-  thread_sched_policy = ZMQ_THREAD_SCHED_POLICY,
-#endif
-#ifdef ZMQ_THREAD_PRIORITY
-  thread_priority = ZMQ_THREAD_PRIORITY,
-#endif
-#ifdef ZMQ_THREAD_AFFINITY_CPU_ADD
-  thread_affinity_cpu_add = ZMQ_THREAD_AFFINITY_CPU_ADD,
-#endif
-#ifdef ZMQ_THREAD_AFFINITY_CPU_REMOVE
-  thread_affinity_cpu_remove = ZMQ_THREAD_AFFINITY_CPU_REMOVE,
-#endif
-#ifdef ZMQ_THREAD_NAME_PREFIX
-  thread_name_prefix = ZMQ_THREAD_NAME_PREFIX,
-#endif
-#ifdef ZMQ_MAX_MSGSZ
-  max_msgsz = ZMQ_MAX_MSGSZ,
-#endif
-#ifdef ZMQ_ZERO_COPY_RECV
-  zero_copy_recv = ZMQ_ZERO_COPY_RECV,
-#endif
-#ifdef ZMQ_MAX_SOCKETS
-  max_sockets = ZMQ_MAX_SOCKETS,
-#endif
-#ifdef ZMQ_SOCKET_LIMIT
-  socket_limit = ZMQ_SOCKET_LIMIT,
-#endif
-#ifdef ZMQ_IPV6
-  ipv6 = ZMQ_IPV6,
-#endif
-#ifdef ZMQ_MSG_T_SIZE
-  msg_t_size = ZMQ_MSG_T_SIZE
-#endif
-};
-#endif
-
-class context_t {
-public:
-  context_t() {
-    ptr = zmq_ctx_new();
-    if (ptr == ZMQ_NULLPTR)
-      throw error_t();
-  }
-
-  explicit context_t(int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT) {
-    ptr = zmq_ctx_new();
-    if (ptr == ZMQ_NULLPTR)
-      throw error_t();
-
-    int rc = zmq_ctx_set(ptr, ZMQ_IO_THREADS, io_threads_);
-    ZMQ_ASSERT(rc == 0);
-
-    rc = zmq_ctx_set(ptr, ZMQ_MAX_SOCKETS, max_sockets_);
-    ZMQ_ASSERT(rc == 0);
-  }
-
-#ifdef ZMQ_HAS_RVALUE_REFS
-  context_t(context_t &&rhs) ZMQ_NOTHROW : ptr(rhs.ptr) {
-    rhs.ptr = ZMQ_NULLPTR;
-  }
-  context_t &operator=(context_t &&rhs) ZMQ_NOTHROW {
-    close();
-    std::swap(ptr, rhs.ptr);
-    return *this;
-  }
-#endif
-
-  ~context_t() ZMQ_NOTHROW { close(); }
-
-  ZMQ_CPP11_DEPRECATED("from 4.7.0, use set taking zmq::ctxopt instead")
-  int setctxopt(int option_, int optval_) {
-    int rc = zmq_ctx_set(ptr, option_, optval_);
-    ZMQ_ASSERT(rc == 0);
-    return rc;
-  }
-
-  ZMQ_CPP11_DEPRECATED("from 4.7.0, use get taking zmq::ctxopt instead")
-  int getctxopt(int option_) { return zmq_ctx_get(ptr, option_); }
-
-#ifdef ZMQ_CPP11
-  void set(ctxopt option, int optval) {
-    int rc = zmq_ctx_set(ptr, static_cast<int>(option), optval);
-    if (rc == -1)
-      throw error_t();
-  }
-
-  ZMQ_NODISCARD int get(ctxopt option) {
-    int rc = zmq_ctx_get(ptr, static_cast<int>(option));
-    // some options have a default value of -1
-    // which is unfortunate, and may result in errors
-    // that don't make sense
-    if (rc == -1)
-      throw error_t();
-    return rc;
-  }
-#endif
-
-  // Terminates context (see also shutdown()).
-  void close() ZMQ_NOTHROW {
-    if (ptr == ZMQ_NULLPTR)
-      return;
-
-    int rc;
-    do {
-      rc = zmq_ctx_term(ptr);
-    } while (rc == -1 && errno == EINTR);
-
-    ZMQ_ASSERT(rc == 0);
-    ptr = ZMQ_NULLPTR;
-  }
-
-  // Shutdown context in preparation for termination (close()).
-  // Causes all blocking socket operations and any further
-  // socket operations to return with ETERM.
-  void shutdown() ZMQ_NOTHROW {
-    if (ptr == ZMQ_NULLPTR)
-      return;
-    int rc = zmq_ctx_shutdown(ptr);
-    ZMQ_ASSERT(rc == 0);
-  }
-
-  //  Be careful with this, it's probably only useful for
-  //  using the C api together with an existing C++ api.
-  //  Normally you should never need to use this.
-  ZMQ_EXPLICIT operator void *() ZMQ_NOTHROW { return ptr; }
-
-  ZMQ_EXPLICIT operator void const *() const ZMQ_NOTHROW { return ptr; }
-
-  ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return ptr; }
-
-  ZMQ_DEPRECATED("from 4.7.0, use handle() != nullptr instead")
-  operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; }
-
-  void swap(context_t &other) ZMQ_NOTHROW { std::swap(ptr, other.ptr); }
-
-private:
-  void *ptr;
-
-  context_t(const context_t &) ZMQ_DELETED_FUNCTION;
-  void operator=(const context_t &) ZMQ_DELETED_FUNCTION;
-};
-
-inline void swap(context_t &a, context_t &b) ZMQ_NOTHROW { a.swap(b); }
-
-#ifdef ZMQ_CPP11
-
-struct recv_buffer_size {
-  size_t size;             // number of bytes written to buffer
-  size_t untruncated_size; // untruncated message size in bytes
-
-  ZMQ_NODISCARD bool truncated() const noexcept {
-    return size != untruncated_size;
-  }
-};
-
-#if CPPZMQ_HAS_OPTIONAL
-
-using send_result_t = std::optional<size_t>;
-using recv_result_t = std::optional<size_t>;
-using recv_buffer_result_t = std::optional<recv_buffer_size>;
-
-#else
-
-namespace detail {
-// A C++11 type emulating the most basic
-// operations of std::optional for trivial types
-template <class T> class trivial_optional {
-public:
-  static_assert(std::is_trivial<T>::value, "T must be trivial");
-  using value_type = T;
-
-  trivial_optional() = default;
-  trivial_optional(T value) noexcept : _value(value), _has_value(true) {}
-
-  const T *operator->() const noexcept {
-    assert(_has_value);
-    return &_value;
-  }
-  T *operator->() noexcept {
-    assert(_has_value);
-    return &_value;
-  }
-
-  const T &operator*() const noexcept {
-    assert(_has_value);
-    return _value;
-  }
-  T &operator*() noexcept {
-    assert(_has_value);
-    return _value;
-  }
-
-  T &value() {
-    if (!_has_value)
-      throw std::exception();
-    return _value;
-  }
-  const T &value() const {
-    if (!_has_value)
-      throw std::exception();
-    return _value;
-  }
-
-  explicit operator bool() const noexcept { return _has_value; }
-  bool has_value() const noexcept { return _has_value; }
-
-private:
-  T _value{};
-  bool _has_value{false};
-};
-} // namespace detail
-
-using send_result_t = detail::trivial_optional<size_t>;
-using recv_result_t = detail::trivial_optional<size_t>;
-using recv_buffer_result_t = detail::trivial_optional<recv_buffer_size>;
-
-#endif
-
-namespace detail {
-template <class T> constexpr T enum_bit_or(T a, T b) noexcept {
-  static_assert(std::is_enum<T>::value, "must be enum");
-  using U = typename std::underlying_type<T>::type;
-  return static_cast<T>(static_cast<U>(a) | static_cast<U>(b));
-}
-template <class T> constexpr T enum_bit_and(T a, T b) noexcept {
-  static_assert(std::is_enum<T>::value, "must be enum");
-  using U = typename std::underlying_type<T>::type;
-  return static_cast<T>(static_cast<U>(a) & static_cast<U>(b));
-}
-template <class T> constexpr T enum_bit_xor(T a, T b) noexcept {
-  static_assert(std::is_enum<T>::value, "must be enum");
-  using U = typename std::underlying_type<T>::type;
-  return static_cast<T>(static_cast<U>(a) ^ static_cast<U>(b));
-}
-template <class T> constexpr T enum_bit_not(T a) noexcept {
-  static_assert(std::is_enum<T>::value, "must be enum");
-  using U = typename std::underlying_type<T>::type;
-  return static_cast<T>(~static_cast<U>(a));
-}
-} // namespace detail
-
-// partially satisfies named requirement BitmaskType
-enum class send_flags : int {
-  none = 0,
-  dontwait = ZMQ_DONTWAIT,
-  sndmore = ZMQ_SNDMORE
-};
-
-constexpr send_flags operator|(send_flags a, send_flags b) noexcept {
-  return detail::enum_bit_or(a, b);
-}
-constexpr send_flags operator&(send_flags a, send_flags b) noexcept {
-  return detail::enum_bit_and(a, b);
-}
-constexpr send_flags operator^(send_flags a, send_flags b) noexcept {
-  return detail::enum_bit_xor(a, b);
-}
-constexpr send_flags operator~(send_flags a) noexcept {
-  return detail::enum_bit_not(a);
-}
-
-// partially satisfies named requirement BitmaskType
-enum class recv_flags : int { none = 0, dontwait = ZMQ_DONTWAIT };
-
-constexpr recv_flags operator|(recv_flags a, recv_flags b) noexcept {
-  return detail::enum_bit_or(a, b);
-}
-constexpr recv_flags operator&(recv_flags a, recv_flags b) noexcept {
-  return detail::enum_bit_and(a, b);
-}
-constexpr recv_flags operator^(recv_flags a, recv_flags b) noexcept {
-  return detail::enum_bit_xor(a, b);
-}
-constexpr recv_flags operator~(recv_flags a) noexcept {
-  return detail::enum_bit_not(a);
-}
-
-// mutable_buffer, const_buffer and buffer are based on
-// the Networking TS specification, draft:
-// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4771.pdf
-
-class mutable_buffer {
-public:
-  constexpr mutable_buffer() noexcept : _data(nullptr), _size(0) {}
-  constexpr mutable_buffer(void *p, size_t n) noexcept : _data(p), _size(n) {
-#ifdef ZMQ_EXTENDED_CONSTEXPR
-    assert(p != nullptr || n == 0);
-#endif
-  }
-
-  constexpr void *data() const noexcept { return _data; }
-  constexpr size_t size() const noexcept { return _size; }
-  mutable_buffer &operator+=(size_t n) noexcept {
-    // (std::min) is a workaround for when a min macro is defined
-    const auto shift = (std::min)(n, _size);
-    _data = static_cast<char *>(_data) + shift;
-    _size -= shift;
-    return *this;
-  }
-
-private:
-  void *_data;
-  size_t _size;
-};
-
-inline mutable_buffer operator+(const mutable_buffer &mb, size_t n) noexcept {
-  return mutable_buffer(static_cast<char *>(mb.data()) +
-                            (std::min)(n, mb.size()),
-                        mb.size() - (std::min)(n, mb.size()));
-}
-inline mutable_buffer operator+(size_t n, const mutable_buffer &mb) noexcept {
-  return mb + n;
-}
-
-class const_buffer {
-public:
-  constexpr const_buffer() noexcept : _data(nullptr), _size(0) {}
-  constexpr const_buffer(const void *p, size_t n) noexcept
-      : _data(p), _size(n) {
-#ifdef ZMQ_EXTENDED_CONSTEXPR
-    assert(p != nullptr || n == 0);
-#endif
-  }
-  constexpr const_buffer(const mutable_buffer &mb) noexcept
-      : _data(mb.data()), _size(mb.size()) {}
-
-  constexpr const void *data() const noexcept { return _data; }
-  constexpr size_t size() const noexcept { return _size; }
-  const_buffer &operator+=(size_t n) noexcept {
-    const auto shift = (std::min)(n, _size);
-    _data = static_cast<const char *>(_data) + shift;
-    _size -= shift;
-    return *this;
-  }
-
-private:
-  const void *_data;
-  size_t _size;
-};
-
-inline const_buffer operator+(const const_buffer &cb, size_t n) noexcept {
-  return const_buffer(static_cast<const char *>(cb.data()) +
-                          (std::min)(n, cb.size()),
-                      cb.size() - (std::min)(n, cb.size()));
-}
-inline const_buffer operator+(size_t n, const const_buffer &cb) noexcept {
-  return cb + n;
-}
-
-// buffer creation
-
-constexpr mutable_buffer buffer(void *p, size_t n) noexcept {
-  return mutable_buffer(p, n);
-}
-constexpr const_buffer buffer(const void *p, size_t n) noexcept {
-  return const_buffer(p, n);
-}
-constexpr mutable_buffer buffer(const mutable_buffer &mb) noexcept {
-  return mb;
-}
-inline mutable_buffer buffer(const mutable_buffer &mb, size_t n) noexcept {
-  return mutable_buffer(mb.data(), (std::min)(mb.size(), n));
-}
-constexpr const_buffer buffer(const const_buffer &cb) noexcept { return cb; }
-inline const_buffer buffer(const const_buffer &cb, size_t n) noexcept {
-  return const_buffer(cb.data(), (std::min)(cb.size(), n));
-}
-
-namespace detail {
-template <class T> struct is_buffer {
-  static constexpr bool value = std::is_same<T, const_buffer>::value ||
-                                std::is_same<T, mutable_buffer>::value;
-};
-
-template <class T> struct is_pod_like {
-  // NOTE: The networking draft N4771 section 16.11 requires
-  // T in the buffer functions below to be
-  // trivially copyable OR standard layout.
-  // Here we decide to be conservative and require both.
-  static constexpr bool value =
-      ZMQ_IS_TRIVIALLY_COPYABLE(T) && std::is_standard_layout<T>::value;
-};
-
-template <class C>
-constexpr auto seq_size(const C &c) noexcept -> decltype(c.size()) {
-  return c.size();
-}
-template <class T, size_t N>
-constexpr size_t seq_size(const T (& /*array*/)[N]) noexcept {
-  return N;
-}
-
-template <class Seq>
-auto buffer_contiguous_sequence(Seq &&seq) noexcept
-    -> decltype(buffer(std::addressof(*std::begin(seq)), size_t{})) {
-  using T = typename std::remove_cv<
-      typename std::remove_reference<decltype(*std::begin(seq))>::type>::type;
-  static_assert(detail::is_pod_like<T>::value, "T must be POD");
-
-  const auto size = seq_size(seq);
-  return buffer(size != 0u ? std::addressof(*std::begin(seq)) : nullptr,
-                size * sizeof(T));
-}
-template <class Seq>
-auto buffer_contiguous_sequence(Seq &&seq, size_t n_bytes) noexcept
-    -> decltype(buffer_contiguous_sequence(seq)) {
-  using T = typename std::remove_cv<
-      typename std::remove_reference<decltype(*std::begin(seq))>::type>::type;
-  static_assert(detail::is_pod_like<T>::value, "T must be POD");
-
-  const auto size = seq_size(seq);
-  return buffer(size != 0u ? std::addressof(*std::begin(seq)) : nullptr,
-                (std::min)(size * sizeof(T), n_bytes));
-}
-
-} // namespace detail
-
-// C array
-template <class T, size_t N> mutable_buffer buffer(T (&data)[N]) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, size_t N>
-mutable_buffer buffer(T (&data)[N], size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-template <class T, size_t N> const_buffer buffer(const T (&data)[N]) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, size_t N>
-const_buffer buffer(const T (&data)[N], size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-// std::array
-template <class T, size_t N>
-mutable_buffer buffer(std::array<T, N> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, size_t N>
-mutable_buffer buffer(std::array<T, N> &data, size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-template <class T, size_t N>
-const_buffer buffer(std::array<const T, N> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, size_t N>
-const_buffer buffer(std::array<const T, N> &data, size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-template <class T, size_t N>
-const_buffer buffer(const std::array<T, N> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, size_t N>
-const_buffer buffer(const std::array<T, N> &data, size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-// std::vector
-template <class T, class Allocator>
-mutable_buffer buffer(std::vector<T, Allocator> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, class Allocator>
-mutable_buffer buffer(std::vector<T, Allocator> &data,
-                      size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-template <class T, class Allocator>
-const_buffer buffer(const std::vector<T, Allocator> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, class Allocator>
-const_buffer buffer(const std::vector<T, Allocator> &data,
-                    size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-// std::basic_string
-template <class T, class Traits, class Allocator>
-mutable_buffer buffer(std::basic_string<T, Traits, Allocator> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, class Traits, class Allocator>
-mutable_buffer buffer(std::basic_string<T, Traits, Allocator> &data,
-                      size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-template <class T, class Traits, class Allocator>
-const_buffer
-buffer(const std::basic_string<T, Traits, Allocator> &data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, class Traits, class Allocator>
-const_buffer buffer(const std::basic_string<T, Traits, Allocator> &data,
-                    size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-
-#if CPPZMQ_HAS_STRING_VIEW
-// std::basic_string_view
-template <class T, class Traits>
-const_buffer buffer(std::basic_string_view<T, Traits> data) noexcept {
-  return detail::buffer_contiguous_sequence(data);
-}
-template <class T, class Traits>
-const_buffer buffer(std::basic_string_view<T, Traits> data,
-                    size_t n_bytes) noexcept {
-  return detail::buffer_contiguous_sequence(data, n_bytes);
-}
-#endif
-
-// Buffer for a string literal (null terminated)
-// where the buffer size excludes the terminating character.
-// Equivalent to zmq::buffer(std::string_view("...")).
-template <class Char, size_t N>
-constexpr const_buffer str_buffer(const Char (&data)[N]) noexcept {
-  static_assert(detail::is_pod_like<Char>::value, "Char must be POD");
-#ifdef ZMQ_EXTENDED_CONSTEXPR
-  assert(data[N - 1] == Char{0});
-#endif
-  return const_buffer(static_cast<const Char *>(data), (N - 1) * sizeof(Char));
-}
-
-namespace literals {
-constexpr const_buffer operator"" _zbuf(const char *str, size_t len) noexcept {
-  return const_buffer(str, len * sizeof(char));
-}
-constexpr const_buffer operator"" _zbuf(const wchar_t *str,
-                                        size_t len) noexcept {
-  return const_buffer(str, len * sizeof(wchar_t));
-}
-constexpr const_buffer operator"" _zbuf(const char16_t *str,
-                                        size_t len) noexcept {
-  return const_buffer(str, len * sizeof(char16_t));
-}
-constexpr const_buffer operator"" _zbuf(const char32_t *str,
-                                        size_t len) noexcept {
-  return const_buffer(str, len * sizeof(char32_t));
-}
-} // namespace literals
-
-#ifdef ZMQ_CPP11
-enum class socket_type : int {
-  req = ZMQ_REQ,
-  rep = ZMQ_REP,
-  dealer = ZMQ_DEALER,
-  router = ZMQ_ROUTER,
-  pub = ZMQ_PUB,
-  sub = ZMQ_SUB,
-  xpub = ZMQ_XPUB,
-  xsub = ZMQ_XSUB,
-  push = ZMQ_PUSH,
-  pull = ZMQ_PULL,
-#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
-  server = ZMQ_SERVER,
-  client = ZMQ_CLIENT,
-  radio = ZMQ_RADIO,
-  dish = ZMQ_DISH,
-  gather = ZMQ_GATHER,
-  scatter = ZMQ_SCATTER,
-  dgram = ZMQ_DGRAM,
-#endif
-#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 3)
-  peer = ZMQ_PEER,
-  channel = ZMQ_CHANNEL,
-#endif
-#if ZMQ_VERSION_MAJOR >= 4
-  stream = ZMQ_STREAM,
-#endif
-  pair = ZMQ_PAIR
-};
-#endif
-
-namespace sockopt {
-// There are two types of options,
-// integral type with known compiler time size (int, bool, int64_t, uint64_t)
-// and arrays with dynamic size (strings, binary data).
-
-// BoolUnit: if true accepts values of type bool (but passed as T into libzmq)
-template <int Opt, class T, bool BoolUnit = false> struct integral_option {};
-
-// NullTerm:
-// 0: binary data
-// 1: null-terminated string (`getsockopt` size includes null)
-// 2: binary (size 32) or Z85 encoder string of size 41 (null included)
-template <int Opt, int NullTerm = 1> struct array_option {};
-
-#define ZMQ_DEFINE_INTEGRAL_OPT(OPT, NAME, TYPE)                               \
-  using NAME##_t = integral_option<OPT, TYPE, false>;                          \
-  ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
-#define ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(OPT, NAME, TYPE)                     \
-  using NAME##_t = integral_option<OPT, TYPE, true>;                           \
-  ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
-#define ZMQ_DEFINE_ARRAY_OPT(OPT, NAME)                                        \
-  using NAME##_t = array_option<OPT>;                                          \
-  ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
-#define ZMQ_DEFINE_ARRAY_OPT_BINARY(OPT, NAME)                                 \
-  using NAME##_t = array_option<OPT, 0>;                                       \
-  ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
-#define ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(OPT, NAME)                             \
-  using NAME##_t = array_option<OPT, 2>;                                       \
-  ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
-
-// deprecated, use zmq::fd_t
-using cppzmq_fd_t = ::zmq::fd_t;
-
-#ifdef ZMQ_AFFINITY
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_AFFINITY, affinity, uint64_t);
-#endif
-#ifdef ZMQ_BACKLOG
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_BACKLOG, backlog, int);
-#endif
-#ifdef ZMQ_BINDTODEVICE
-ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_BINDTODEVICE, bindtodevice);
-#endif
-#ifdef ZMQ_CONFLATE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_CONFLATE, conflate, int);
-#endif
-#ifdef ZMQ_CONNECT_ROUTING_ID
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_CONNECT_ROUTING_ID, connect_routing_id);
-#endif
-#ifdef ZMQ_CONNECT_TIMEOUT
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_CONNECT_TIMEOUT, connect_timeout, int);
-#endif
-#ifdef ZMQ_CURVE_PUBLICKEY
-ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_PUBLICKEY, curve_publickey);
-#endif
-#ifdef ZMQ_CURVE_SECRETKEY
-ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_SECRETKEY, curve_secretkey);
-#endif
-#ifdef ZMQ_CURVE_SERVER
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_CURVE_SERVER, curve_server, int);
-#endif
-#ifdef ZMQ_CURVE_SERVERKEY
-ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_SERVERKEY, curve_serverkey);
-#endif
-#ifdef ZMQ_DISCONNECT_MSG
-ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_DISCONNECT_MSG, disconnect_msg);
-#endif
-#ifdef ZMQ_EVENTS
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_EVENTS, events, int);
-#endif
-#ifdef ZMQ_FD
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_FD, fd, ::zmq::fd_t);
-#endif
-#ifdef ZMQ_GSSAPI_PLAINTEXT
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_GSSAPI_PLAINTEXT, gssapi_plaintext, int);
-#endif
-#ifdef ZMQ_GSSAPI_SERVER
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_GSSAPI_SERVER, gssapi_server, int);
-#endif
-#ifdef ZMQ_GSSAPI_SERVICE_PRINCIPAL
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_GSSAPI_SERVICE_PRINCIPAL, gssapi_service_principal);
-#endif
-#ifdef ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE,
-                        gssapi_service_principal_nametype, int);
-#endif
-#ifdef ZMQ_GSSAPI_PRINCIPAL
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_GSSAPI_PRINCIPAL, gssapi_principal);
-#endif
-#ifdef ZMQ_GSSAPI_PRINCIPAL_NAMETYPE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_GSSAPI_PRINCIPAL_NAMETYPE,
-                        gssapi_principal_nametype, int);
-#endif
-#ifdef ZMQ_HANDSHAKE_IVL
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HANDSHAKE_IVL, handshake_ivl, int);
-#endif
-#ifdef ZMQ_HEARTBEAT_IVL
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_IVL, heartbeat_ivl, int);
-#endif
-#ifdef ZMQ_HEARTBEAT_TIMEOUT
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_TIMEOUT, heartbeat_timeout, int);
-#endif
-#ifdef ZMQ_HEARTBEAT_TTL
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_TTL, heartbeat_ttl, int);
-#endif
-#ifdef ZMQ_HELLO_MSG
-ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_HELLO_MSG, hello_msg);
-#endif
-#ifdef ZMQ_IMMEDIATE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_IMMEDIATE, immediate, int);
-#endif
-#ifdef ZMQ_INVERT_MATCHING
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_INVERT_MATCHING, invert_matching, int);
-#endif
-#ifdef ZMQ_IPV6
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_IPV6, ipv6, int);
-#endif
-#ifdef ZMQ_LAST_ENDPOINT
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_LAST_ENDPOINT, last_endpoint);
-#endif
-#ifdef ZMQ_LINGER
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_LINGER, linger, int);
-#endif
-#ifdef ZMQ_MAXMSGSIZE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MAXMSGSIZE, maxmsgsize, int64_t);
-#endif
-#ifdef ZMQ_MECHANISM
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MECHANISM, mechanism, int);
-#endif
-#ifdef ZMQ_METADATA
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_METADATA, metadata);
-#endif
-#ifdef ZMQ_MULTICAST_HOPS
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_HOPS, multicast_hops, int);
-#endif
-#ifdef ZMQ_MULTICAST_LOOP
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_MULTICAST_LOOP, multicast_loop, int);
-#endif
-#ifdef ZMQ_MULTICAST_MAXTPDU
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_MAXTPDU, multicast_maxtpdu, int);
-#endif
-#ifdef ZMQ_ONLY_FIRST_SUBSCRIBE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ONLY_FIRST_SUBSCRIBE,
-                                  only_first_subscribe, int);
-#endif
-#ifdef ZMQ_PLAIN_SERVER
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PLAIN_SERVER, plain_server, int);
-#endif
-#ifdef ZMQ_PLAIN_PASSWORD
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_PLAIN_PASSWORD, plain_password);
-#endif
-#ifdef ZMQ_PLAIN_USERNAME
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_PLAIN_USERNAME, plain_username);
-#endif
-#ifdef ZMQ_PRIORITY
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_PRIORITY, priority, int);
-#endif
-#ifdef ZMQ_USE_FD
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_USE_FD, use_fd, int);
-#endif
-#ifdef ZMQ_PROBE_ROUTER
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PROBE_ROUTER, probe_router, int);
-#endif
-#ifdef ZMQ_RATE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RATE, rate, int);
-#endif
-#ifdef ZMQ_RCVBUF
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVBUF, rcvbuf, int);
-#endif
-#ifdef ZMQ_RCVHWM
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVHWM, rcvhwm, int);
-#endif
-#ifdef ZMQ_RCVMORE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_RCVMORE, rcvmore, int);
-#endif
-#ifdef ZMQ_RCVTIMEO
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVTIMEO, rcvtimeo, int);
-#endif
-#ifdef ZMQ_RECONNECT_IVL
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_IVL, reconnect_ivl, int);
-#endif
-#ifdef ZMQ_RECONNECT_IVL_MAX
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_IVL_MAX, reconnect_ivl_max, int);
-#endif
-#ifdef ZMQ_RECONNECT_STOP
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_STOP, reconnect_stop, int);
-#endif
-#ifdef ZMQ_RECOVERY_IVL
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECOVERY_IVL, recovery_ivl, int);
-#endif
-#ifdef ZMQ_REQ_CORRELATE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_REQ_CORRELATE, req_correlate, int);
-#endif
-#ifdef ZMQ_REQ_RELAXED
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_REQ_RELAXED, req_relaxed, int);
-#endif
-#ifdef ZMQ_ROUTER_HANDOVER
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ROUTER_HANDOVER, router_handover, int);
-#endif
-#ifdef ZMQ_ROUTER_MANDATORY
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ROUTER_MANDATORY, router_mandatory, int);
-#endif
-#ifdef ZMQ_ROUTER_NOTIFY
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_ROUTER_NOTIFY, router_notify, int);
-#endif
-#ifdef ZMQ_ROUTING_ID
-ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_ROUTING_ID, routing_id);
-#endif
-#ifdef ZMQ_SNDBUF
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDBUF, sndbuf, int);
-#endif
-#ifdef ZMQ_SNDHWM
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDHWM, sndhwm, int);
-#endif
-#ifdef ZMQ_SNDTIMEO
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDTIMEO, sndtimeo, int);
-#endif
-#ifdef ZMQ_SOCKS_PASSWORD
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_SOCKS_PASSWORD, socks_password);
-#endif
-#ifdef ZMQ_SOCKS_PROXY
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_SOCKS_PROXY, socks_proxy);
-#endif
-#ifdef ZMQ_SOCKS_USERNAME
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_SOCKS_USERNAME, socks_username);
-#endif
-#ifdef ZMQ_STREAM_NOTIFY
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_STREAM_NOTIFY, stream_notify, int);
-#endif
-#ifdef ZMQ_SUBSCRIBE
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_SUBSCRIBE, subscribe);
-#endif
-#ifdef ZMQ_TCP_KEEPALIVE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE, tcp_keepalive, int);
-#endif
-#ifdef ZMQ_TCP_KEEPALIVE_CNT
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_CNT, tcp_keepalive_cnt, int);
-#endif
-#ifdef ZMQ_TCP_KEEPALIVE_IDLE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_IDLE, tcp_keepalive_idle, int);
-#endif
-#ifdef ZMQ_TCP_KEEPALIVE_INTVL
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_INTVL, tcp_keepalive_intvl, int);
-#endif
-#ifdef ZMQ_TCP_MAXRT
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_MAXRT, tcp_maxrt, int);
-#endif
-#ifdef ZMQ_THREAD_SAFE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_THREAD_SAFE, thread_safe, int);
-#endif
-#ifdef ZMQ_TOS
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TOS, tos, int);
-#endif
-#ifdef ZMQ_TYPE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TYPE, type, int);
-#ifdef ZMQ_CPP11
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TYPE, socket_type, socket_type);
-#endif // ZMQ_CPP11
-#endif // ZMQ_TYPE
-#ifdef ZMQ_UNSUBSCRIBE
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_UNSUBSCRIBE, unsubscribe);
-#endif
-#ifdef ZMQ_VMCI_BUFFER_SIZE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_SIZE, vmci_buffer_size, uint64_t);
-#endif
-#ifdef ZMQ_VMCI_BUFFER_MIN_SIZE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_MIN_SIZE, vmci_buffer_min_size,
-                        uint64_t);
-#endif
-#ifdef ZMQ_VMCI_BUFFER_MAX_SIZE
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_MAX_SIZE, vmci_buffer_max_size,
-                        uint64_t);
-#endif
-#ifdef ZMQ_VMCI_CONNECT_TIMEOUT
-ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_CONNECT_TIMEOUT, vmci_connect_timeout, int);
-#endif
-#ifdef ZMQ_XPUB_VERBOSE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSE, xpub_verbose, int);
-#endif
-#ifdef ZMQ_XPUB_VERBOSER
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSER, xpub_verboser, int);
-#endif
-#ifdef ZMQ_XPUB_MANUAL
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL, xpub_manual, int);
-#endif
-#ifdef ZMQ_XPUB_MANUAL_LAST_VALUE
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL_LAST_VALUE,
-                                  xpub_manual_last_value, int);
-#endif
-#ifdef ZMQ_XPUB_NODROP
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_NODROP, xpub_nodrop, int);
-#endif
-#ifdef ZMQ_XPUB_WELCOME_MSG
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_XPUB_WELCOME_MSG, xpub_welcome_msg);
-#endif
-#ifdef ZMQ_ZAP_ENFORCE_DOMAIN
-ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ZAP_ENFORCE_DOMAIN, zap_enforce_domain,
-                                  int);
-#endif
-#ifdef ZMQ_ZAP_DOMAIN
-ZMQ_DEFINE_ARRAY_OPT(ZMQ_ZAP_DOMAIN, zap_domain);
-#endif
-
-} // namespace sockopt
-#endif // ZMQ_CPP11
-
-namespace detail {
-class socket_base {
-public:
-  socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {}
-  ZMQ_EXPLICIT socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {}
-
-  template <typename T>
-  ZMQ_CPP11_DEPRECATED("from 4.7.0, use `set` taking option from zmq::sockopt")
-  void setsockopt(int option_, T const &optval) {
-    setsockopt(option_, &optval, sizeof(T));
-  }
-
-  ZMQ_CPP11_DEPRECATED("from 4.7.0, use `set` taking option from zmq::sockopt")
-  void setsockopt(int option_, const void *optval_, size_t optvallen_) {
-    int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  ZMQ_CPP11_DEPRECATED("from 4.7.0, use `get` taking option from zmq::sockopt")
-  void getsockopt(int option_, void *optval_, size_t *optvallen_) const {
-    int rc = zmq_getsockopt(_handle, option_, optval_, optvallen_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  template <typename T>
-  ZMQ_CPP11_DEPRECATED("from 4.7.0, use `get` taking option from zmq::sockopt")
-  T getsockopt(int option_) const {
-    T optval;
-    size_t optlen = sizeof(T);
-    getsockopt(option_, &optval, &optlen);
-    return optval;
-  }
-
-#ifdef ZMQ_CPP11
-  // Set integral socket option, e.g.
-  // `socket.set(zmq::sockopt::linger, 0)`
-  template <int Opt, class T, bool BoolUnit>
-  void set(sockopt::integral_option<Opt, T, BoolUnit>, const T &val) {
-    static_assert(std::is_integral<T>::value, "T must be integral");
-    set_option(Opt, &val, sizeof val);
-  }
-
-  // Set integral socket option from boolean, e.g.
-  // `socket.set(zmq::sockopt::immediate, false)`
-  template <int Opt, class T>
-  void set(sockopt::integral_option<Opt, T, true>, bool val) {
-    static_assert(std::is_integral<T>::value, "T must be integral");
-    T rep_val = val;
-    set_option(Opt, &rep_val, sizeof rep_val);
-  }
-
-  // Set array socket option, e.g.
-  // `socket.set(zmq::sockopt::plain_username, "foo123")`
-  template <int Opt, int NullTerm>
-  void set(sockopt::array_option<Opt, NullTerm>, const char *buf) {
-    set_option(Opt, buf, std::strlen(buf));
-  }
-
-  // Set array socket option, e.g.
-  // `socket.set(zmq::sockopt::routing_id, zmq::buffer(id))`
-  template <int Opt, int NullTerm>
-  void set(sockopt::array_option<Opt, NullTerm>, const_buffer buf) {
-    set_option(Opt, buf.data(), buf.size());
-  }
-
-  // Set array socket option, e.g.
-  // `socket.set(zmq::sockopt::routing_id, id_str)`
-  template <int Opt, int NullTerm>
-  void set(sockopt::array_option<Opt, NullTerm>, const std::string &buf) {
-    set_option(Opt, buf.data(), buf.size());
-  }
-
-#if CPPZMQ_HAS_STRING_VIEW
-  // Set array socket option, e.g.
-  // `socket.set(zmq::sockopt::routing_id, id_str)`
-  template <int Opt, int NullTerm>
-  void set(sockopt::array_option<Opt, NullTerm>, std::string_view buf) {
-    set_option(Opt, buf.data(), buf.size());
-  }
-#endif
-
-  // Get scalar socket option, e.g.
-  // `auto opt = socket.get(zmq::sockopt::linger)`
-  template <int Opt, class T, bool BoolUnit>
-  ZMQ_NODISCARD T get(sockopt::integral_option<Opt, T, BoolUnit>) const {
-    static_assert(std::is_scalar<T>::value, "T must be scalar");
-    T val;
-    size_t size = sizeof val;
-    get_option(Opt, &val, &size);
-    assert(size == sizeof val);
-    return val;
-  }
-
-  // Get array socket option, writes to buf, returns option size in bytes, e.g.
-  // `size_t optsize = socket.get(zmq::sockopt::routing_id, zmq::buffer(id))`
-  template <int Opt, int NullTerm>
-  ZMQ_NODISCARD size_t get(sockopt::array_option<Opt, NullTerm>,
-                           mutable_buffer buf) const {
-    size_t size = buf.size();
-    get_option(Opt, buf.data(), &size);
-    return size;
-  }
-
-  // Get array socket option as string (initializes the string buffer size to
-  // init_size) e.g. `auto s = socket.get(zmq::sockopt::routing_id)` Note:
-  // removes the null character from null-terminated string options, i.e. the
-  // string size excludes the null character.
-  template <int Opt, int NullTerm>
-  ZMQ_NODISCARD std::string get(sockopt::array_option<Opt, NullTerm>,
-                                size_t init_size = 1024) const {
-    if ZMQ_CONSTEXPR_IF (NullTerm == 2) {
-      if (init_size == 1024) {
-        init_size = 41; // get as Z85 string
-      }
-    }
-    std::string str(init_size, '\0');
-    size_t size = get(sockopt::array_option<Opt>{}, buffer(str));
-    if ZMQ_CONSTEXPR_IF (NullTerm == 1) {
-      if (size > 0) {
-        assert(str[size - 1] == '\0');
-        --size;
-      }
-    } else if ZMQ_CONSTEXPR_IF (NullTerm == 2) {
-      assert(size == 32 || size == 41);
-      if (size == 41) {
-        assert(str[size - 1] == '\0');
-        --size;
-      }
-    }
-    str.resize(size);
-    return str;
-  }
-#endif
-
-  void bind(std::string const &addr) { bind(addr.c_str()); }
-
-  void bind(const char *addr_) {
-    int rc = zmq_bind(_handle, addr_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  void unbind(std::string const &addr) { unbind(addr.c_str()); }
-
-  void unbind(const char *addr_) {
-    int rc = zmq_unbind(_handle, addr_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  void connect(std::string const &addr) { connect(addr.c_str()); }
-
-  void connect(const char *addr_) {
-    int rc = zmq_connect(_handle, addr_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  void disconnect(std::string const &addr) { disconnect(addr.c_str()); }
-
-  void disconnect(const char *addr_) {
-    int rc = zmq_disconnect(_handle, addr_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  ZMQ_DEPRECATED("from 4.7.1, use handle() != nullptr or operator bool")
-  bool connected() const ZMQ_NOTHROW { return (_handle != ZMQ_NULLPTR); }
-
-  ZMQ_CPP11_DEPRECATED(
-      "from 4.3.1, use send taking a const_buffer and send_flags")
-  size_t send(const void *buf_, size_t len_, int flags_ = 0) {
-    int nbytes = zmq_send(_handle, buf_, len_, flags_);
-    if (nbytes >= 0)
-      return static_cast<size_t>(nbytes);
-    if (zmq_errno() == EAGAIN)
-      return 0;
-    throw error_t();
-  }
-
-  ZMQ_CPP11_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
-  bool send(message_t &msg_,
-            int flags_ = 0) // default until removed
-  {
-    int nbytes = zmq_msg_send(msg_.handle(), _handle, flags_);
-    if (nbytes >= 0)
-      return true;
-    if (zmq_errno() == EAGAIN)
-      return false;
-    throw error_t();
-  }
-
-  template <typename T>
-  ZMQ_CPP11_DEPRECATED(
-      "from 4.4.1, use send taking message_t or buffer (for contiguous "
-      "ranges), and send_flags")
-  bool send(T first, T last, int flags_ = 0) {
-    zmq::message_t msg(first, last);
-    int nbytes = zmq_msg_send(msg.handle(), _handle, flags_);
-    if (nbytes >= 0)
-      return true;
-    if (zmq_errno() == EAGAIN)
-      return false;
-    throw error_t();
-  }
-
-#ifdef ZMQ_HAS_RVALUE_REFS
-  ZMQ_CPP11_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
-  bool send(message_t &&msg_,
-            int flags_ = 0) // default until removed
-  {
-#ifdef ZMQ_CPP11
-    return send(msg_, static_cast<send_flags>(flags_)).has_value();
-#else
-    return send(msg_, flags_);
-#endif
-  }
-#endif
-
-#ifdef ZMQ_CPP11
-  send_result_t send(const_buffer buf, send_flags flags = send_flags::none) {
-    const int nbytes =
-        zmq_send(_handle, buf.data(), buf.size(), static_cast<int>(flags));
-    if (nbytes >= 0)
-      return static_cast<size_t>(nbytes);
-    if (zmq_errno() == EAGAIN)
-      return {};
-    throw error_t();
-  }
-
-  send_result_t send(message_t &msg, send_flags flags) {
-    int nbytes = zmq_msg_send(msg.handle(), _handle, static_cast<int>(flags));
-    if (nbytes >= 0)
-      return static_cast<size_t>(nbytes);
-    if (zmq_errno() == EAGAIN)
-      return {};
-    throw error_t();
-  }
-
-  send_result_t send(message_t &&msg, send_flags flags) {
-    return send(msg, flags);
-  }
-#endif
-
-  ZMQ_CPP11_DEPRECATED(
-      "from 4.3.1, use recv taking a mutable_buffer and recv_flags")
-  size_t recv(void *buf_, size_t len_, int flags_ = 0) {
-    int nbytes = zmq_recv(_handle, buf_, len_, flags_);
-    if (nbytes >= 0)
-      return static_cast<size_t>(nbytes);
-    if (zmq_errno() == EAGAIN)
-      return 0;
-    throw error_t();
-  }
-
-  ZMQ_CPP11_DEPRECATED(
-      "from 4.3.1, use recv taking a reference to message_t and recv_flags")
-  bool recv(message_t *msg_, int flags_ = 0) {
-    int nbytes = zmq_msg_recv(msg_->handle(), _handle, flags_);
-    if (nbytes >= 0)
-      return true;
-    if (zmq_errno() == EAGAIN)
-      return false;
-    throw error_t();
-  }
-
-#ifdef ZMQ_CPP11
-  ZMQ_NODISCARD
-  recv_buffer_result_t recv(mutable_buffer buf,
-                            recv_flags flags = recv_flags::none) {
-    const int nbytes =
-        zmq_recv(_handle, buf.data(), buf.size(), static_cast<int>(flags));
-    if (nbytes >= 0) {
-      return recv_buffer_size{
-          (std::min)(static_cast<size_t>(nbytes), buf.size()),
-          static_cast<size_t>(nbytes)};
-    }
-    if (zmq_errno() == EAGAIN)
-      return {};
-    throw error_t();
-  }
-
-  ZMQ_NODISCARD
-  recv_result_t recv(message_t &msg, recv_flags flags = recv_flags::none) {
-    const int nbytes =
-        zmq_msg_recv(msg.handle(), _handle, static_cast<int>(flags));
-    if (nbytes >= 0) {
-      assert(msg.size() == static_cast<size_t>(nbytes));
-      return static_cast<size_t>(nbytes);
-    }
-    if (zmq_errno() == EAGAIN)
-      return {};
-    throw error_t();
-  }
-#endif
-
-#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
-  void join(const char *group) {
-    int rc = zmq_join(_handle, group);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  void leave(const char *group) {
-    int rc = zmq_leave(_handle, group);
-    if (rc != 0)
-      throw error_t();
-  }
-#endif
-
-  ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return _handle; }
-  ZMQ_NODISCARD const void *handle() const ZMQ_NOTHROW { return _handle; }
-
-  ZMQ_EXPLICIT operator bool() const ZMQ_NOTHROW {
-    return _handle != ZMQ_NULLPTR;
-  }
-  // note: non-const operator bool can be removed once
-  // operator void* is removed from socket_t
-  ZMQ_EXPLICIT operator bool() ZMQ_NOTHROW { return _handle != ZMQ_NULLPTR; }
-
-protected:
-  void *_handle;
-
-private:
-  void set_option(int option_, const void *optval_, size_t optvallen_) {
-    int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
-    if (rc != 0)
-      throw error_t();
-  }
-
-  void get_option(int option_, void *optval_, size_t *optvallen_) const {
-    int rc = zmq_getsockopt(_handle, option_, optval_, optvallen_);
-    if (rc != 0)
-      throw error_t();
-  }
-};
-} // namespace detail
-
-struct from_handle_t {
-  struct _private {}; // disabling use other than with from_handle
-  ZMQ_CONSTEXPR_FN ZMQ_EXPLICIT from_handle_t(_private /*p*/) ZMQ_NOTHROW {}
-};
-
-ZMQ_CONSTEXPR_VAR from_handle_t from_handle =
-    from_handle_t(from_handle_t::_private());
-
-// A non-owning nullable reference to a socket.
-// The reference is invalidated on socket close or destruction.
-class socket_ref : public detail::socket_base {
-public:
-  socket_ref() ZMQ_NOTHROW : detail::socket_base() {}
-#ifdef ZMQ_CPP11
-  socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {}
-#endif
-  socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW
-      : detail::socket_base(handle) {}
-};
-
-#ifdef ZMQ_CPP11
-inline bool operator==(socket_ref sr, std::nullptr_t /*p*/) ZMQ_NOTHROW {
-  return sr.handle() == nullptr;
-}
-inline bool operator==(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW {
-  return sr.handle() == nullptr;
-}
-inline bool operator!=(socket_ref sr, std::nullptr_t /*p*/) ZMQ_NOTHROW {
-  return !(sr == nullptr);
-}
-inline bool operator!=(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW {
-  return !(sr == nullptr);
-}
-#endif
-
-inline bool operator==(const detail::socket_base &a,
-                       const detail::socket_base &b) ZMQ_NOTHROW {
-  return std::equal_to<const void *>()(a.handle(), b.handle());
-}
-inline bool operator!=(const detail::socket_base &a,
-                       const detail::socket_base &b) ZMQ_NOTHROW {
-  return !(a == b);
-}
-inline bool operator<(const detail::socket_base &a,
-                      const detail::socket_base &b) ZMQ_NOTHROW {
-  return std::less<const void *>()(a.handle(), b.handle());
-}
-inline bool operator>(const detail::socket_base &a,
-                      const detail::socket_base &b) ZMQ_NOTHROW {
-  return b < a;
-}
-inline bool operator<=(const detail::socket_base &a,
-                       const detail::socket_base &b) ZMQ_NOTHROW {
-  return !(a > b);
-}
-inline bool operator>=(const detail::socket_base &a,
-                       const detail::socket_base &b) ZMQ_NOTHROW {
-  return !(a < b);
-}
-
-} // namespace zmq
-
-#ifdef ZMQ_CPP11
-namespace std {
-template <> struct hash<zmq::socket_ref> {
-  size_t operator()(zmq::socket_ref sr) const ZMQ_NOTHROW {
-    return hash<void *>()(sr.handle());
-  }
-};
-} // namespace std
-#endif
-
-namespace zmq {
-class socket_t : public detail::socket_base {
-  friend class monitor_t;
-
-public:
-  socket_t() ZMQ_NOTHROW : detail::socket_base(ZMQ_NULLPTR),
-                           ctxptr(ZMQ_NULLPTR) {}
-
-  socket_t(context_t &context_, int type_)
-      : detail::socket_base(zmq_socket(context_.handle(), type_)),
-        ctxptr(context_.handle()) {
-    if (_handle == ZMQ_NULLPTR)
-      throw error_t();
-  }
-
-#ifdef ZMQ_CPP11
-  socket_t(context_t &context_, socket_type type_)
-      : socket_t(context_, static_cast<int>(type_)) {}
-#endif
-
-#ifdef ZMQ_HAS_RVALUE_REFS
-  socket_t(socket_t &&rhs) ZMQ_NOTHROW : detail::socket_base(rhs._handle),
-                                         ctxptr(rhs.ctxptr) {
-    rhs._handle = ZMQ_NULLPTR;
-    rhs.ctxptr = ZMQ_NULLPTR;
-  }
-  socket_t &operator=(socket_t &&rhs) ZMQ_NOTHROW {
-    close();
-    std::swap(_handle, rhs._handle);
-    std::swap(ctxptr, rhs.ctxptr);
-    return *this;
-  }
-#endif
-
-  ~socket_t() ZMQ_NOTHROW { close(); }
-
-  operator void *() ZMQ_NOTHROW { return _handle; }
-
-  operator void const *() const ZMQ_NOTHROW { return _handle; }
-
-  void close() ZMQ_NOTHROW {
-    if (_handle == ZMQ_NULLPTR)
-      // already closed
-      return;
-    int rc = zmq_close(_handle);
-    ZMQ_ASSERT(rc == 0);
-    _handle = ZMQ_NULLPTR;
-    ctxptr = ZMQ_NULLPTR;
-  }
-
-  void swap(socket_t &other) ZMQ_NOTHROW {
-    std::swap(_handle, other._handle);
-    std::swap(ctxptr, other.ctxptr);
-  }
-
-  operator socket_ref() ZMQ_NOTHROW { return socket_ref(from_handle, _handle); }
-
-private:
-  void *ctxptr;
-
-  socket_t(const socket_t &) ZMQ_DELETED_FUNCTION;
-  void operator=(const socket_t &) ZMQ_DELETED_FUNCTION;
-
-  // used by monitor_t
-  socket_t(void *context_, int type_)
-      : detail::socket_base(zmq_socket(context_, type_)), ctxptr(context_) {
-    if (_handle == ZMQ_NULLPTR)
-      throw error_t();
-    if (ctxptr == ZMQ_NULLPTR)
-      throw error_t();
-  }
-};
-
-inline void swap(socket_t &a, socket_t &b) ZMQ_NOTHROW { a.swap(b); }
-
-ZMQ_DEPRECATED("from 4.3.1, use proxy taking socket_t objects")
-inline void proxy(void *frontend, void *backend, void *capture) {
-  int rc = zmq_proxy(frontend, backend, capture);
-  if (rc != 0)
-    throw error_t();
-}
-
-inline void proxy(socket_ref frontend, socket_ref backend,
-                  socket_ref capture = socket_ref()) {
-  int rc = zmq_proxy(frontend.handle(), backend.handle(), capture.handle());
-  if (rc != 0)
-    throw error_t();
-}
-
-#ifdef ZMQ_HAS_PROXY_STEERABLE
-ZMQ_DEPRECATED("from 4.3.1, use proxy_steerable taking socket_t objects")
-inline void proxy_steerable(void *frontend, void *backend, void *capture,
-                            void *control) {
-  int rc = zmq_proxy_steerable(frontend, backend, capture, control);
-  if (rc != 0)
-    throw error_t();
-}
-
-inline void proxy_steerable(socket_ref frontend, socket_ref backend,
-                            socket_ref capture, socket_ref control) {
-  int rc = zmq_proxy_steerable(frontend.handle(), backend.handle(),
-                               capture.handle(), control.handle());
-  if (rc != 0)
-    throw error_t();
-}
-#endif
-
-class monitor_t {
-public:
-  monitor_t() : _socket(), _monitor_socket() {}
-
-  virtual ~monitor_t() { close(); }
-
-#ifdef ZMQ_HAS_RVALUE_REFS
-  monitor_t(monitor_t &&rhs) ZMQ_NOTHROW : _socket(), _monitor_socket() {
-    std::swap(_socket, rhs._socket);
-    std::swap(_monitor_socket, rhs._monitor_socket);
-  }
-
-  monitor_t &operator=(monitor_t &&rhs) ZMQ_NOTHROW {
-    close();
-    _socket = socket_ref();
-    std::swap(_socket, rhs._socket);
-    std::swap(_monitor_socket, rhs._monitor_socket);
-    return *this;
-  }
-#endif
-
-  void monitor(socket_t &socket, std::string const &addr,
-               int events = ZMQ_EVENT_ALL) {
-    monitor(socket, addr.c_str(), events);
-  }
-
-  void monitor(socket_t &socket, const char *addr_,
-               int events = ZMQ_EVENT_ALL) {
-    init(socket, addr_, events);
-    while (true) {
-      check_event(-1);
-    }
-  }
-
-  void init(socket_t &socket, std::string const &addr,
-            int events = ZMQ_EVENT_ALL) {
-    init(socket, addr.c_str(), events);
-  }
-
-  void init(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL) {
-    int rc = zmq_socket_monitor(socket.handle(), addr_, events);
-    if (rc != 0)
-      throw error_t();
-
-    _socket = socket;
-    _monitor_socket = socket_t(socket.ctxptr, ZMQ_PAIR);
-    _monitor_socket.connect(addr_);
-
-    on_monitor_started();
-  }
-
-  bool check_event(int timeout = 0) {
-    assert(_monitor_socket);
-
-    zmq::message_t eventMsg;
-
-    zmq::pollitem_t items[] = {
-        {_monitor_socket.handle(), 0, ZMQ_POLLIN, 0},
-    };
-
-#ifdef ZMQ_CPP11
-    zmq::poll(&items[0], 1, std::chrono::milliseconds(timeout));
-#else
-    zmq::poll(&items[0], 1, timeout);
-#endif
-
-    if (items[0].revents & ZMQ_POLLIN) {
-      int rc = zmq_msg_recv(eventMsg.handle(), _monitor_socket.handle(), 0);
-      if (rc == -1 && zmq_errno() == ETERM)
-        return false;
-      assert(rc != -1);
-
-    } else {
-      return false;
-    }
-
-#if ZMQ_VERSION_MAJOR >= 4
-    const char *data = static_cast<const char *>(eventMsg.data());
-    zmq_event_t msgEvent;
-    memcpy(&msgEvent.event, data, sizeof(uint16_t));
-    data += sizeof(uint16_t);
-    memcpy(&msgEvent.value, data, sizeof(int32_t));
-    zmq_event_t *event = &msgEvent;
-#else
-    zmq_event_t *event = static_cast<zmq_event_t *>(eventMsg.data());
-#endif
-
-#ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT
-    zmq::message_t addrMsg;
-    int rc = zmq_msg_recv(addrMsg.handle(), _monitor_socket.handle(), 0);
-    if (rc == -1 && zmq_errno() == ETERM) {
-      return false;
-    }
-
-    assert(rc != -1);
-    std::string address = addrMsg.to_string();
-#else
-    // Bit of a hack, but all events in the zmq_event_t union have the same
-    // layout so this will work for all event types.
-    std::string address = event->data.connected.addr;
-#endif
-
-#ifdef ZMQ_EVENT_MONITOR_STOPPED
-    if (event->event == ZMQ_EVENT_MONITOR_STOPPED) {
-      return false;
-    }
-
-#endif
-
-    switch (event->event) {
-    case ZMQ_EVENT_CONNECTED:
-      on_event_connected(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_CONNECT_DELAYED:
-      on_event_connect_delayed(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_CONNECT_RETRIED:
-      on_event_connect_retried(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_LISTENING:
-      on_event_listening(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_BIND_FAILED:
-      on_event_bind_failed(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_ACCEPTED:
-      on_event_accepted(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_ACCEPT_FAILED:
-      on_event_accept_failed(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_CLOSED:
-      on_event_closed(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_CLOSE_FAILED:
-      on_event_close_failed(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_DISCONNECTED:
-      on_event_disconnected(*event, address.c_str());
-      break;
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 0) ||                                \
-    (defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3))
-    case ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL:
-      on_event_handshake_failed_no_detail(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL:
-      on_event_handshake_failed_protocol(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_HANDSHAKE_FAILED_AUTH:
-      on_event_handshake_failed_auth(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_HANDSHAKE_SUCCEEDED:
-      on_event_handshake_succeeded(*event, address.c_str());
-      break;
-#elif defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
-    case ZMQ_EVENT_HANDSHAKE_FAILED:
-      on_event_handshake_failed(*event, address.c_str());
-      break;
-    case ZMQ_EVENT_HANDSHAKE_SUCCEED:
-      on_event_handshake_succeed(*event, address.c_str());
-      break;
-#endif
-    default:
-      on_event_unknown(*event, address.c_str());
-      break;
-    }
-
-    return true;
-  }
-
-#ifdef ZMQ_EVENT_MONITOR_STOPPED
-  void abort() {
-    if (_socket)
-      zmq_socket_monitor(_socket.handle(), ZMQ_NULLPTR, 0);
-
-    _socket = socket_ref();
-  }
-#endif
-  virtual void on_monitor_started() {}
-  virtual void on_event_connected(const zmq_event_t &event_,
-                                  const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_connect_delayed(const zmq_event_t &event_,
-                                        const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_connect_retried(const zmq_event_t &event_,
-                                        const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_listening(const zmq_event_t &event_,
-                                  const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_bind_failed(const zmq_event_t &event_,
-                                    const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_accepted(const zmq_event_t &event_, const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_accept_failed(const zmq_event_t &event_,
-                                      const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_closed(const zmq_event_t &event_, const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_close_failed(const zmq_event_t &event_,
-                                     const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_disconnected(const zmq_event_t &event_,
-                                     const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
-  virtual void on_event_handshake_failed_no_detail(const zmq_event_t &event_,
-                                                   const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_handshake_failed_protocol(const zmq_event_t &event_,
-                                                  const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_handshake_failed_auth(const zmq_event_t &event_,
-                                              const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_handshake_succeeded(const zmq_event_t &event_,
-                                            const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-#elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
-  virtual void on_event_handshake_failed(const zmq_event_t &event_,
-                                         const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-  virtual void on_event_handshake_succeed(const zmq_event_t &event_,
-                                          const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-#endif
-  virtual void on_event_unknown(const zmq_event_t &event_, const char *addr_) {
-    (void)event_;
-    (void)addr_;
-  }
-
-private:
-  monitor_t(const monitor_t &) ZMQ_DELETED_FUNCTION;
-  void operator=(const monitor_t &) ZMQ_DELETED_FUNCTION;
-
-  socket_ref _socket;
-  socket_t _monitor_socket;
-
-  void close() ZMQ_NOTHROW {
-    if (_socket)
-      zmq_socket_monitor(_socket.handle(), ZMQ_NULLPTR, 0);
-    _monitor_socket.close();
-  }
-};
-
-#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) &&                      \
-    defined(ZMQ_HAVE_POLLER)
-
-// polling events
-enum class event_flags : short {
-  none = 0,
-  pollin = ZMQ_POLLIN,
-  pollout = ZMQ_POLLOUT,
-  pollerr = ZMQ_POLLERR,
-  pollpri = ZMQ_POLLPRI
-};
-
-constexpr event_flags operator|(event_flags a, event_flags b) noexcept {
-  return detail::enum_bit_or(a, b);
-}
-constexpr event_flags operator&(event_flags a, event_flags b) noexcept {
-  return detail::enum_bit_and(a, b);
-}
-constexpr event_flags operator^(event_flags a, event_flags b) noexcept {
-  return detail::enum_bit_xor(a, b);
-}
-constexpr event_flags operator~(event_flags a) noexcept {
-  return detail::enum_bit_not(a);
-}
-
-struct no_user_data;
-
-// layout compatible with zmq_poller_event_t
-template <class T = no_user_data> struct poller_event {
-  socket_ref socket;
-  ::zmq::fd_t fd;
-  T *user_data;
-  event_flags events;
-};
-
-template <typename T = no_user_data> class poller_t {
-public:
-  using event_type = poller_event<T>;
-
-  poller_t() : poller_ptr(zmq_poller_new()) {
-    if (!poller_ptr)
-      throw error_t();
-  }
-
-  template <typename Dummy = void,
-            typename = typename std::enable_if<
-                !std::is_same<T, no_user_data>::value, Dummy>::type>
-  void add(zmq::socket_ref socket, event_flags events, T *user_data) {
-    add_impl(socket, events, user_data);
-  }
-
-  void add(zmq::socket_ref socket, event_flags events) {
-    add_impl(socket, events, nullptr);
-  }
-
-  template <typename Dummy = void,
-            typename = typename std::enable_if<
-                !std::is_same<T, no_user_data>::value, Dummy>::type>
-  void add(fd_t fd, event_flags events, T *user_data) {
-    add_impl(fd, events, user_data);
-  }
-
-  void add(fd_t fd, event_flags events) { add_impl(fd, events, nullptr); }
-
-  void remove(zmq::socket_ref socket) {
-    if (0 != zmq_poller_remove(poller_ptr.get(), socket.handle())) {
-      throw error_t();
-    }
-  }
-
-  void modify(zmq::socket_ref socket, event_flags events) {
-    if (0 != zmq_poller_modify(poller_ptr.get(), socket.handle(),
-                               static_cast<short>(events))) {
-      throw error_t();
-    }
-  }
-
-  size_t wait_all(std::vector<event_type> &poller_events,
-                  const std::chrono::milliseconds timeout) {
-    int rc = zmq_poller_wait_all(
-        poller_ptr.get(),
-        reinterpret_cast<zmq_poller_event_t *>(poller_events.data()),
-        static_cast<int>(poller_events.size()),
-        static_cast<long>(timeout.count()));
-    if (rc > 0)
-      return static_cast<size_t>(rc);
-
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
-    if (zmq_errno() == EAGAIN)
-#else
-    if (zmq_errno() == ETIMEDOUT)
-#endif
-      return 0;
-
-    throw error_t();
-  }
-
-#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 3)
-  size_t size() const noexcept {
-    int rc = zmq_poller_size(const_cast<void *>(poller_ptr.get()));
-    ZMQ_ASSERT(rc >= 0);
-    return static_cast<size_t>(std::max(rc, 0));
-  }
-#endif
-
-private:
-  struct destroy_poller_t {
-    void operator()(void *ptr) noexcept {
-      int rc = zmq_poller_destroy(&ptr);
-      ZMQ_ASSERT(rc == 0);
-    }
-  };
-
-  std::unique_ptr<void, destroy_poller_t> poller_ptr;
-
-  void add_impl(zmq::socket_ref socket, event_flags events, T *user_data) {
-    if (0 != zmq_poller_add(poller_ptr.get(), socket.handle(), user_data,
-                            static_cast<short>(events))) {
-      throw error_t();
-    }
-  }
-
-  void add_impl(fd_t fd, event_flags events, T *user_data) {
-    if (0 != zmq_poller_add_fd(poller_ptr.get(), fd, user_data,
-                               static_cast<short>(events))) {
-      throw error_t();
-    }
-  }
-};
-#endif //  defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) &&
-       //  defined(ZMQ_HAVE_POLLER)
-
-inline std::ostream &operator<<(std::ostream &os, const message_t &msg) {
-  return os << msg.str();
-}
-
-} // namespace zmq
-
-#endif // __ZMQ_HPP_INCLUDED__
diff --git a/client/rsh/inst/zmq_addon.hpp b/client/rsh/inst/zmq_addon.hpp
deleted file mode 100644
index 958eec56d..000000000
--- a/client/rsh/inst/zmq_addon.hpp
+++ /dev/null
@@ -1,753 +0,0 @@
-/*
-    Copyright (c) 2016-2017 ZeroMQ community
-    Copyright (c) 2016 VOCA AS / Harald Nøkland
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to
-    deal in the Software without restriction, including without limitation the
-    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-    sell copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-*/
-
-#ifndef __ZMQ_ADDON_HPP_INCLUDED__
-#define __ZMQ_ADDON_HPP_INCLUDED__
-
-#include "zmq.hpp"
-
-#include <deque>
-#include <iomanip>
-#include <sstream>
-#include <stdexcept>
-#ifdef ZMQ_CPP11
-#include <limits>
-#include <functional>
-#include <unordered_map>
-#endif
-
-namespace zmq
-{
-#ifdef ZMQ_CPP11
-
-namespace detail
-{
-template<bool CheckN, class OutputIt>
-recv_result_t
-recv_multipart_n(socket_ref s, OutputIt out, size_t n, recv_flags flags)
-{
-    size_t msg_count = 0;
-    message_t msg;
-    while (true) {
-        if ZMQ_CONSTEXPR_IF (CheckN) {
-            if (msg_count >= n)
-                throw std::runtime_error(
-                  "Too many message parts in recv_multipart_n");
-        }
-        if (!s.recv(msg, flags)) {
-            // zmq ensures atomic delivery of messages
-            assert(msg_count == 0);
-            return {};
-        }
-        ++msg_count;
-        const bool more = msg.more();
-        *out++ = std::move(msg);
-        if (!more)
-            break;
-    }
-    return msg_count;
-}
-
-inline bool is_little_endian()
-{
-    const uint16_t i = 0x01;
-    return *reinterpret_cast<const uint8_t *>(&i) == 0x01;
-}
-
-inline void write_network_order(unsigned char *buf, const uint32_t value)
-{
-    if (is_little_endian()) {
-        ZMQ_CONSTEXPR_VAR uint32_t mask = (std::numeric_limits<std::uint8_t>::max)();
-        *buf++ = static_cast<unsigned char>((value >> 24) & mask);
-        *buf++ = static_cast<unsigned char>((value >> 16) & mask);
-        *buf++ = static_cast<unsigned char>((value >> 8) & mask);
-        *buf++ = static_cast<unsigned char>(value & mask);
-    } else {
-        std::memcpy(buf, &value, sizeof(value));
-    }
-}
-
-inline uint32_t read_u32_network_order(const unsigned char *buf)
-{
-    if (is_little_endian()) {
-        return (static_cast<uint32_t>(buf[0]) << 24)
-               + (static_cast<uint32_t>(buf[1]) << 16)
-               + (static_cast<uint32_t>(buf[2]) << 8)
-               + static_cast<uint32_t>(buf[3]);
-    } else {
-        uint32_t value;
-        std::memcpy(&value, buf, sizeof(value));
-        return value;
-    }
-}
-} // namespace detail
-
-/*  Receive a multipart message.
-    
-    Writes the zmq::message_t objects to OutputIterator out.
-    The out iterator must handle an unspecified number of writes,
-    e.g. by using std::back_inserter.
-    
-    Returns: the number of messages received or nullopt (on EAGAIN).
-    Throws: if recv throws. Any exceptions thrown
-    by the out iterator will be propagated and the message
-    may have been only partially received with pending
-    message parts. It is adviced to close this socket in that event.
-*/
-template<class OutputIt>
-ZMQ_NODISCARD recv_result_t recv_multipart(socket_ref s,
-                                           OutputIt out,
-                                           recv_flags flags = recv_flags::none)
-{
-    return detail::recv_multipart_n<false>(s, std::move(out), 0, flags);
-}
-
-/*  Receive a multipart message.
-    
-    Writes at most n zmq::message_t objects to OutputIterator out.
-    If the number of message parts of the incoming message exceeds n
-    then an exception will be thrown.
-    
-    Returns: the number of messages received or nullopt (on EAGAIN).
-    Throws: if recv throws. Throws std::runtime_error if the number
-    of message parts exceeds n (exactly n messages will have been written
-    to out). Any exceptions thrown
-    by the out iterator will be propagated and the message
-    may have been only partially received with pending
-    message parts. It is adviced to close this socket in that event.
-*/
-template<class OutputIt>
-ZMQ_NODISCARD recv_result_t recv_multipart_n(socket_ref s,
-                                             OutputIt out,
-                                             size_t n,
-                                             recv_flags flags = recv_flags::none)
-{
-    return detail::recv_multipart_n<true>(s, std::move(out), n, flags);
-}
-
-/*  Send a multipart message.
-    
-    The range must be a ForwardRange of zmq::message_t,
-    zmq::const_buffer or zmq::mutable_buffer.
-    The flags may be zmq::send_flags::sndmore if there are 
-    more message parts to be sent after the call to this function.
-    
-    Returns: the number of messages sent (exactly msgs.size()) or nullopt (on EAGAIN).
-    Throws: if send throws. Any exceptions thrown
-    by the msgs range will be propagated and the message
-    may have been only partially sent. It is adviced to close this socket in that event.
-*/
-template<class Range
-#ifndef ZMQ_CPP11_PARTIAL
-         ,
-         typename = typename std::enable_if<
-           detail::is_range<Range>::value
-           && (std::is_same<detail::range_value_t<Range>, message_t>::value
-               || detail::is_buffer<detail::range_value_t<Range>>::value)>::type
-#endif
-         >
-send_result_t
-send_multipart(socket_ref s, Range &&msgs, send_flags flags = send_flags::none)
-{
-    using std::begin;
-    using std::end;
-    auto it = begin(msgs);
-    const auto end_it = end(msgs);
-    size_t msg_count = 0;
-    while (it != end_it) {
-        const auto next = std::next(it);
-        const auto msg_flags =
-          flags | (next == end_it ? send_flags::none : send_flags::sndmore);
-        if (!s.send(*it, msg_flags)) {
-            // zmq ensures atomic delivery of messages
-            assert(it == begin(msgs));
-            return {};
-        }
-        ++msg_count;
-        it = next;
-    }
-    return msg_count;
-}
-
-/* Encode a multipart message.
-
-   The range must be a ForwardRange of zmq::message_t.  A
-   zmq::multipart_t or STL container may be passed for encoding.
-
-   Returns: a zmq::message_t holding the encoded multipart data.
-
-   Throws: std::range_error is thrown if the size of any single part
-   can not fit in an unsigned 32 bit integer.
-
-   The encoding is compatible with that used by the CZMQ function
-   zmsg_encode(), see https://rfc.zeromq.org/spec/50/.
-   Each part consists of a size followed by the data.
-   These are placed contiguously into the output message.  A part of
-   size less than 255 bytes will have a single byte size value.
-   Larger parts will have a five byte size value with the first byte
-   set to 0xFF and the remaining four bytes holding the size of the
-   part's data.
-*/
-template<class Range
-#ifndef ZMQ_CPP11_PARTIAL
-         ,
-         typename = typename std::enable_if<
-           detail::is_range<Range>::value
-           && (std::is_same<detail::range_value_t<Range>, message_t>::value
-               || detail::is_buffer<detail::range_value_t<Range>>::value)>::type
-#endif
-         >
-message_t encode(const Range &parts)
-{
-    size_t mmsg_size = 0;
-
-    // First pass check sizes
-    for (const auto &part : parts) {
-        const size_t part_size = part.size();
-        if (part_size > (std::numeric_limits<std::uint32_t>::max)()) {
-            // Size value must fit into uint32_t.
-            throw std::range_error("Invalid size, message part too large");
-        }
-        const size_t count_size =
-          part_size < (std::numeric_limits<std::uint8_t>::max)() ? 1 : 5;
-        mmsg_size += part_size + count_size;
-    }
-
-    message_t encoded(mmsg_size);
-    unsigned char *buf = encoded.data<unsigned char>();
-    for (const auto &part : parts) {
-        const uint32_t part_size = static_cast<uint32_t>(part.size());
-        const unsigned char *part_data =
-          static_cast<const unsigned char *>(part.data());
-
-        if (part_size < (std::numeric_limits<std::uint8_t>::max)()) {
-            // small part
-            *buf++ = (unsigned char) part_size;
-        } else {
-            // big part
-            *buf++ = (std::numeric_limits<uint8_t>::max)();
-            detail::write_network_order(buf, part_size);
-            buf += sizeof(part_size);
-        }
-        std::memcpy(buf, part_data, part_size);
-        buf += part_size;
-    }
-
-    assert(static_cast<size_t>(buf - encoded.data<unsigned char>()) == mmsg_size);
-    return encoded;
-}
-
-/*  Decode an encoded message to multiple parts.
-
-    The given output iterator must be a ForwardIterator to a container
-    holding zmq::message_t such as a zmq::multipart_t or various STL
-    containers.
-
-    Returns the ForwardIterator advanced once past the last decoded
-    part.
-
-    Throws: a std::out_of_range is thrown if the encoded part sizes
-    lead to exceeding the message data bounds.
-
-    The decoding assumes the message is encoded in the manner
-    performed by zmq::encode(), see https://rfc.zeromq.org/spec/50/.
- */
-template<class OutputIt> OutputIt decode(const message_t &encoded, OutputIt out)
-{
-    const unsigned char *source = encoded.data<unsigned char>();
-    const unsigned char *const limit = source + encoded.size();
-
-    while (source < limit) {
-        size_t part_size = *source++;
-        if (part_size == (std::numeric_limits<std::uint8_t>::max)()) {
-            if (static_cast<size_t>(limit - source) < sizeof(uint32_t)) {
-                throw std::out_of_range(
-                  "Malformed encoding, overflow in reading size");
-            }
-            part_size = detail::read_u32_network_order(source);
-            // the part size is allowed to be less than 0xFF
-            source += sizeof(uint32_t);
-        }
-
-        if (static_cast<size_t>(limit - source) < part_size) {
-            throw std::out_of_range("Malformed encoding, overflow in reading part");
-        }
-        *out = message_t(source, part_size);
-        ++out;
-        source += part_size;
-    }
-
-    assert(source == limit);
-    return out;
-}
-
-#endif
-
-
-#ifdef ZMQ_HAS_RVALUE_REFS
-
-/*
-    This class handles multipart messaging. It is the C++ equivalent of zmsg.h,
-    which is part of CZMQ (the high-level C binding). Furthermore, it is a major
-    improvement compared to zmsg.hpp, which is part of the examples in the ØMQ
-    Guide. Unnecessary copying is avoided by using move semantics to efficiently
-    add/remove parts.
-*/
-class multipart_t
-{
-  private:
-    std::deque<message_t> m_parts;
-
-  public:
-    typedef std::deque<message_t>::value_type value_type;
-
-    typedef std::deque<message_t>::iterator iterator;
-    typedef std::deque<message_t>::const_iterator const_iterator;
-
-    typedef std::deque<message_t>::reverse_iterator reverse_iterator;
-    typedef std::deque<message_t>::const_reverse_iterator const_reverse_iterator;
-
-    // Default constructor
-    multipart_t() {}
-
-    // Construct from socket receive
-    multipart_t(socket_ref socket) { recv(socket); }
-
-    // Construct from memory block
-    multipart_t(const void *src, size_t size) { addmem(src, size); }
-
-    // Construct from string
-    multipart_t(const std::string &string) { addstr(string); }
-
-    // Construct from message part
-    multipart_t(message_t &&message) { add(std::move(message)); }
-
-    // Move constructor
-    multipart_t(multipart_t &&other) ZMQ_NOTHROW { m_parts = std::move(other.m_parts); }
-
-    // Move assignment operator
-    multipart_t &operator=(multipart_t &&other) ZMQ_NOTHROW
-    {
-        m_parts = std::move(other.m_parts);
-        return *this;
-    }
-
-    // Destructor
-    virtual ~multipart_t() { clear(); }
-
-    message_t &operator[](size_t n) { return m_parts[n]; }
-
-    const message_t &operator[](size_t n) const { return m_parts[n]; }
-
-    message_t &at(size_t n) { return m_parts.at(n); }
-
-    const message_t &at(size_t n) const { return m_parts.at(n); }
-
-    iterator begin() { return m_parts.begin(); }
-
-    const_iterator begin() const { return m_parts.begin(); }
-
-    const_iterator cbegin() const { return m_parts.cbegin(); }
-
-    reverse_iterator rbegin() { return m_parts.rbegin(); }
-
-    const_reverse_iterator rbegin() const { return m_parts.rbegin(); }
-
-    iterator end() { return m_parts.end(); }
-
-    const_iterator end() const { return m_parts.end(); }
-
-    const_iterator cend() const { return m_parts.cend(); }
-
-    reverse_iterator rend() { return m_parts.rend(); }
-
-    const_reverse_iterator rend() const { return m_parts.rend(); }
-
-    // Delete all parts
-    void clear() { m_parts.clear(); }
-
-    // Get number of parts
-    size_t size() const { return m_parts.size(); }
-
-    // Check if number of parts is zero
-    bool empty() const { return m_parts.empty(); }
-
-    // Receive multipart message from socket
-    bool recv(socket_ref socket, int flags = 0)
-    {
-        clear();
-        bool more = true;
-        while (more) {
-            message_t message;
-#ifdef ZMQ_CPP11
-            if (!socket.recv(message, static_cast<recv_flags>(flags)))
-                return false;
-#else
-            if (!socket.recv(&message, flags))
-                return false;
-#endif
-            more = message.more();
-            add(std::move(message));
-        }
-        return true;
-    }
-
-    // Send multipart message to socket
-    bool send(socket_ref socket, int flags = 0)
-    {
-        flags &= ~(ZMQ_SNDMORE);
-        bool more = size() > 0;
-        while (more) {
-            message_t message = pop();
-            more = size() > 0;
-#ifdef ZMQ_CPP11
-            if (!socket.send(message, static_cast<send_flags>(
-                                        (more ? ZMQ_SNDMORE : 0) | flags)))
-                return false;
-#else
-            if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
-                return false;
-#endif
-        }
-        clear();
-        return true;
-    }
-
-    // Concatenate other multipart to front
-    void prepend(multipart_t &&other)
-    {
-        while (!other.empty())
-            push(other.remove());
-    }
-
-    // Concatenate other multipart to back
-    void append(multipart_t &&other)
-    {
-        while (!other.empty())
-            add(other.pop());
-    }
-
-    // Push memory block to front
-    void pushmem(const void *src, size_t size)
-    {
-        m_parts.push_front(message_t(src, size));
-    }
-
-    // Push memory block to back
-    void addmem(const void *src, size_t size)
-    {
-        m_parts.push_back(message_t(src, size));
-    }
-
-    // Push string to front
-    void pushstr(const std::string &string)
-    {
-        m_parts.push_front(message_t(string.data(), string.size()));
-    }
-
-    // Push string to back
-    void addstr(const std::string &string)
-    {
-        m_parts.push_back(message_t(string.data(), string.size()));
-    }
-
-    // Push type (fixed-size) to front
-    template<typename T> void pushtyp(const T &type)
-    {
-        static_assert(!std::is_same<T, std::string>::value,
-                      "Use pushstr() instead of pushtyp<std::string>()");
-        m_parts.push_front(message_t(&type, sizeof(type)));
-    }
-
-    // Push type (fixed-size) to back
-    template<typename T> void addtyp(const T &type)
-    {
-        static_assert(!std::is_same<T, std::string>::value,
-                      "Use addstr() instead of addtyp<std::string>()");
-        m_parts.push_back(message_t(&type, sizeof(type)));
-    }
-
-    // Push message part to front
-    void push(message_t &&message) { m_parts.push_front(std::move(message)); }
-
-    // Push message part to back
-    void add(message_t &&message) { m_parts.push_back(std::move(message)); }
-
-    // Alias to allow std::back_inserter()
-    void push_back(message_t &&message) { m_parts.push_back(std::move(message)); }
-
-    // Pop string from front
-    std::string popstr()
-    {
-        std::string string(m_parts.front().data<char>(), m_parts.front().size());
-        m_parts.pop_front();
-        return string;
-    }
-
-    // Pop type (fixed-size) from front
-    template<typename T> T poptyp()
-    {
-        static_assert(!std::is_same<T, std::string>::value,
-                      "Use popstr() instead of poptyp<std::string>()");
-        if (sizeof(T) != m_parts.front().size())
-            throw std::runtime_error(
-              "Invalid type, size does not match the message size");
-        T type = *m_parts.front().data<T>();
-        m_parts.pop_front();
-        return type;
-    }
-
-    // Pop message part from front
-    message_t pop()
-    {
-        message_t message = std::move(m_parts.front());
-        m_parts.pop_front();
-        return message;
-    }
-
-    // Pop message part from back
-    message_t remove()
-    {
-        message_t message = std::move(m_parts.back());
-        m_parts.pop_back();
-        return message;
-    }
-
-    // get message part from front
-    const message_t &front() { return m_parts.front(); }
-
-    // get message part from back
-    const message_t &back() { return m_parts.back(); }
-
-    // Get pointer to a specific message part
-    const message_t *peek(size_t index) const { return &m_parts[index]; }
-
-    // Get a string copy of a specific message part
-    std::string peekstr(size_t index) const
-    {
-        std::string string(m_parts[index].data<char>(), m_parts[index].size());
-        return string;
-    }
-
-    // Peek type (fixed-size) from front
-    template<typename T> T peektyp(size_t index) const
-    {
-        static_assert(!std::is_same<T, std::string>::value,
-                      "Use peekstr() instead of peektyp<std::string>()");
-        if (sizeof(T) != m_parts[index].size())
-            throw std::runtime_error(
-              "Invalid type, size does not match the message size");
-        T type = *m_parts[index].data<T>();
-        return type;
-    }
-
-    // Create multipart from type (fixed-size)
-    template<typename T> static multipart_t create(const T &type)
-    {
-        multipart_t multipart;
-        multipart.addtyp(type);
-        return multipart;
-    }
-
-    // Copy multipart
-    multipart_t clone() const
-    {
-        multipart_t multipart;
-        for (size_t i = 0; i < size(); i++)
-            multipart.addmem(m_parts[i].data(), m_parts[i].size());
-        return multipart;
-    }
-
-    // Dump content to string
-    std::string str() const
-    {
-        std::stringstream ss;
-        for (size_t i = 0; i < m_parts.size(); i++) {
-            const unsigned char *data = m_parts[i].data<unsigned char>();
-            size_t size = m_parts[i].size();
-
-            // Dump the message as text or binary
-            bool isText = true;
-            for (size_t j = 0; j < size; j++) {
-                if (data[j] < 32 || data[j] > 127) {
-                    isText = false;
-                    break;
-                }
-            }
-            ss << "\n[" << std::dec << std::setw(3) << std::setfill('0') << size
-               << "] ";
-            if (size >= 1000) {
-                ss << "... (too big to print)";
-                continue;
-            }
-            for (size_t j = 0; j < size; j++) {
-                if (isText)
-                    ss << static_cast<char>(data[j]);
-                else
-                    ss << std::hex << std::setw(2) << std::setfill('0')
-                       << static_cast<short>(data[j]);
-            }
-        }
-        return ss.str();
-    }
-
-    // Check if equal to other multipart
-    bool equal(const multipart_t *other) const ZMQ_NOTHROW
-    {
-        return *this == *other;
-    }
-
-    bool operator==(const multipart_t &other) const ZMQ_NOTHROW
-    {
-        if (size() != other.size())
-            return false;
-        for (size_t i = 0; i < size(); i++)
-            if (at(i) != other.at(i))
-                return false;
-        return true;
-    }
-
-    bool operator!=(const multipart_t &other) const ZMQ_NOTHROW
-    {
-        return !(*this == other);
-    }
-
-#ifdef ZMQ_CPP11
-
-    // Return single part message_t encoded from this multipart_t.
-    message_t encode() const { return zmq::encode(*this); }
-
-    // Decode encoded message into multiple parts and append to self.
-    void decode_append(const message_t &encoded)
-    {
-        zmq::decode(encoded, std::back_inserter(*this));
-    }
-
-    // Return a new multipart_t containing the decoded message_t.
-    static multipart_t decode(const message_t &encoded)
-    {
-        multipart_t tmp;
-        zmq::decode(encoded, std::back_inserter(tmp));
-        return tmp;
-    }
-
-#endif
-
-  private:
-    // Disable implicit copying (moving is more efficient)
-    multipart_t(const multipart_t &other) ZMQ_DELETED_FUNCTION;
-    void operator=(const multipart_t &other) ZMQ_DELETED_FUNCTION;
-}; // class multipart_t
-
-inline std::ostream &operator<<(std::ostream &os, const multipart_t &msg)
-{
-    return os << msg.str();
-}
-
-#endif // ZMQ_HAS_RVALUE_REFS
-
-#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
-class active_poller_t
-{
-  public:
-    active_poller_t() = default;
-    ~active_poller_t() = default;
-
-    active_poller_t(const active_poller_t &) = delete;
-    active_poller_t &operator=(const active_poller_t &) = delete;
-
-    active_poller_t(active_poller_t &&src) = default;
-    active_poller_t &operator=(active_poller_t &&src) = default;
-
-    using handler_type = std::function<void(event_flags)>;
-
-    void add(zmq::socket_ref socket, event_flags events, handler_type handler)
-    {
-        if (!handler)
-            throw std::invalid_argument("null handler in active_poller_t::add");
-        auto ret = handlers.emplace(
-          socket, std::make_shared<handler_type>(std::move(handler)));
-        if (!ret.second)
-            throw error_t(EINVAL); // already added
-        try {
-            base_poller.add(socket, events, ret.first->second.get());
-            need_rebuild = true;
-        }
-        catch (...) {
-            // rollback
-            handlers.erase(socket);
-            throw;
-        }
-    }
-
-    void remove(zmq::socket_ref socket)
-    {
-        base_poller.remove(socket);
-        handlers.erase(socket);
-        need_rebuild = true;
-    }
-
-    void modify(zmq::socket_ref socket, event_flags events)
-    {
-        base_poller.modify(socket, events);
-    }
-
-    size_t wait(std::chrono::milliseconds timeout)
-    {
-        if (need_rebuild) {
-            poller_events.resize(handlers.size());
-            poller_handlers.clear();
-            poller_handlers.reserve(handlers.size());
-            for (const auto &handler : handlers) {
-                poller_handlers.push_back(handler.second);
-            }
-            need_rebuild = false;
-        }
-        const auto count = base_poller.wait_all(poller_events, timeout);
-        std::for_each(poller_events.begin(),
-                      poller_events.begin() + static_cast<ptrdiff_t>(count),
-                      [](decltype(base_poller)::event_type &event) {
-                          assert(event.user_data != nullptr);
-                          (*event.user_data)(event.events);
-                      });
-        return count;
-    }
-
-    ZMQ_NODISCARD bool empty() const noexcept { return handlers.empty(); }
-
-    size_t size() const noexcept { return handlers.size(); }
-
-  private:
-    bool need_rebuild{false};
-
-    poller_t<handler_type> base_poller{};
-    std::unordered_map<socket_ref, std::shared_ptr<handler_type>> handlers{};
-    std::vector<decltype(base_poller)::event_type> poller_events{};
-    std::vector<std::shared_ptr<handler_type>> poller_handlers{};
-};     // class active_poller_t
-#endif //  defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
-
-
-} // namespace zmq
-
-#endif // __ZMQ_ADDON_HPP_INCLUDED__
diff --git a/client/rsh/src/client.h b/client/rsh/src/client.h
index 750bab5d0..eeca32669 100644
--- a/client/rsh/src/client.h
+++ b/client/rsh/src/client.h
@@ -11,7 +11,6 @@
 #include <vector>
 #include <variant>
 #include <unordered_map>
-#include <zmq.hpp>
 #include <grpc/grpc.h>
 #include <grpcpp/channel.h>
 

From e845e4a8e8f96ba384a9d72b0f9fc083c2a41228 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 6 Sep 2024 17:00:10 +0200
Subject: [PATCH 53/80] Fix test to follow new API

---
 client/rsh/test6.R | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index 75b635ef5..e16dc8e30 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -10,7 +10,7 @@ f <- function(x) {
 
 print(f)
 
-rsh::rsh_compile(f, tier = "bytecode", opt_level = 3L)
+rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
 print(f)
 
 print(f(5))
@@ -18,12 +18,12 @@ print(f(5))
 stopifnot(f(5) == 52)
 
 # f should be in the compile cache now.
-rsh::rsh_compile(f, tier = "bytecode", opt_level = 3L)
+rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
 
 stopifnot(f(5) == 52)
 
 # another opt level so it should be recompiled
-rsh::rsh_compile(f, tier = "bytecode", opt_level = 2L)
+rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
 
 stopifnot(f(5) == 52)
 
@@ -32,6 +32,6 @@ f <- function(x) {
 }
 
 # body changed so it should be recompiled
-rsh::rsh_compile(f, tier = "bytecode", opt_level = 2L)
+rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
 
 stopifnot(f(5) == 8)
\ No newline at end of file

From d0de919e59e54fe80d936b5460cb0354bf9e69c2 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 6 Sep 2024 17:30:44 +0200
Subject: [PATCH 54/80] Native code compilation: integration of JITService

---
 .../org/prlprg/server/CompileService.java     | 105 +++++++++++-------
 .../java/org/prlprg/service/JITService.java   |   3 +
 2 files changed, 67 insertions(+), 41 deletions(-)

diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 37d9f99d3..871f26143 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -12,6 +12,7 @@
 import org.prlprg.bc.BCCompiler;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.rds.RDSWriter;
+import org.prlprg.service.JITService;
 import org.prlprg.session.GNURSession;
 import org.prlprg.sexp.BCodeSXP;
 import org.prlprg.sexp.CloSXP;
@@ -29,6 +30,7 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   // not the Bc (or BcCodeSXP)
   // Key is (hash, optimisationLevel)
   private HashMap<Pair<Long, Integer>, ByteString> bcCache = new HashMap<>();
+  private JITService jitService = null; // TODO: merge it with the compile service
 
   // TODO: cache for native code, which should also include contexts
 
@@ -46,7 +48,6 @@ public void compile(
     // Parse the request
     Messages.Function function = request.getFunction();
     Messages.Tier tier = request.getTier(); // Default is baseline
-    int optimizationLevel = request.getBcOpt(); // default is 0
     Messages.Context context = request.getContext(); // null if not provided
 
     logger.info(
@@ -54,53 +55,73 @@ public void compile(
             + function.getName()
             + " at tier "
             + tier
-            + " with optimization level "
-            + optimizationLevel);
+            + " with bytecode level "
+            + request.getBcOpt()
+            + " and native optimization level "
+            + request.getCcOpt());
 
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
-
-    // First see if we have the hash in the cache
-    var bcKey = Pair.of(function.getHash(), optimizationLevel);
-    ByteString cached = bcCache.get(bcKey);
-    if (cached != null) {
-      logger.info("Found " + function.getName() + " in cache. No recompilation.");
-      try {
-        response.setCode(cached);
-      } catch (Exception e) {
-        throw new RuntimeException("Impossible to serialize the bytecode");
-      }
-    } else {
-      logger.info(
-          "Compile function "
-              + function.getName()
-              + " with optimisation level "
-              + optimizationLevel
-              + ": not found in cache.");
-      if (function.hasBody()) {
+    if (tier.equals(Messages.Tier.BASELINE)) {
+      // First see if we have the hash in the cache
+      var bcKey = Pair.of(function.getHash(), request.getBcOpt());
+      ByteString cached = bcCache.get(bcKey);
+      if (cached != null) {
+        logger.info("Found " + function.getName() + " in cache. No recompilation.");
         try {
-          ByteString serializedBc =
-              compileClosure(function.getBody(), optimizationLevel, responseObserver);
-          response.setCode(serializedBc);
-          // Add it to the cache
-          bcCache.put(bcKey, serializedBc);
+          response.setCode(cached);
         } catch (Exception e) {
-          // See
-          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
-          // We could have more details using that:
-          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
-          responseObserver.onError(
-              Status.INTERNAL
-                  .withDescription(
-                      "Cannot compile function " + function.getName() + " ; " + e.getMessage())
-                  .asRuntimeException());
+          throw new RuntimeException("Impossible to serialize the bytecode");
         }
-      } else { // No body
-        // we need to ask the client for the body
+      } else {
         logger.info(
-            "No body sent with the request for function "
+            "Compile function "
                 + function.getName()
-                + ". Cannot compile.");
+                + " with optimisation level "
+                + request.getBcOpt()
+                + ": not found in cache.");
+        if (function.hasBody()) {
+          try {
+            ByteString serializedBc =
+                compileBcClosure(function.getBody(), request.getBcOpt(), responseObserver);
+            response.setCode(serializedBc);
+            // Add it to the cache
+            bcCache.put(bcKey, serializedBc);
+          } catch (Exception e) {
+            // See
+            // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+            // We could have more details using that:
+            // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
+            responseObserver.onError(
+                Status.INTERNAL
+                    .withDescription(
+                        "Cannot compile function " + function.getName() + " ; " + e.getMessage())
+                    .asRuntimeException());
+          }
+        } else { // No body
+          // TODO: we need to ask the client for the body
+          logger.info(
+              "No body sent with the request for function "
+                  + function.getName()
+                  + ". Cannot compile.");
+        }
+      }
+    } else { // OPTIMIZED tier => native
+      try {
+        var closure = (CloSXP) RDSReader.readByteString(session, function.getBody());
+        // TODO: rewrite this here to reuse the bytecode cache
+        // TODO: add a native cache
+        var nativeClosure =
+            jitService.execute(function.getName(), closure, request.getBcOpt(), request.getCcOpt());
+        response.setCode(ByteString.copyFrom(nativeClosure.code()));
+        ByteString constantPool = RDSWriter.writeByteString(nativeClosure.constantPool());
+        response.setConstants(constantPool);
+      } catch (Exception e) {
+        responseObserver.onError(
+            Status.INTERNAL
+                .withDescription(
+                    "Cannot compile function " + function.getName() + " ; " + e.getMessage())
+                .asRuntimeException());
       }
     }
 
@@ -137,6 +158,8 @@ public void init(
     lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     session = new GNURSession(convertVersion(RVersion), r_dir, Path.of(lib_dir));
 
+    jitService = new JITService(session);
+
     // TODO: Look into our cache if we have the packages.
     // Request the packages for those we do not have hashes for.
 
@@ -148,7 +171,7 @@ private RVersion convertVersion(Messages.Version version) {
     return new RVersion(version.getMajor(), version.getMinor(), version.getPatch());
   }
 
-  private ByteString compileClosure(
+  private ByteString compileBcClosure(
       ByteString body,
       int optimizationLevel,
       StreamObserver<Messages.CompileResponse> responseObserver) {
diff --git a/server/src/main/java/org/prlprg/service/JITService.java b/server/src/main/java/org/prlprg/service/JITService.java
index c987bcbd8..f74736c85 100644
--- a/server/src/main/java/org/prlprg/service/JITService.java
+++ b/server/src/main/java/org/prlprg/service/JITService.java
@@ -9,6 +9,9 @@
 import org.prlprg.session.RSession;
 import org.prlprg.sexp.CloSXP;
 
+// TODO: e should rename/refactor all this package and this class (because we also have a
+// CompileService in the server)
+
 public class JITService {
   private final RSession rsession;
 

From 7e3168aae75849327d5543799114d407ab3a79be Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 9 Sep 2024 17:49:20 +0200
Subject: [PATCH 55/80] Remove JItService, port it into the CompileService.
 Native code caching.

---
 .../org/prlprg/server/CompileService.java     | 195 +++++++++++-------
 .../java/org/prlprg/service/JITService.java   |  66 ------
 .../org/prlprg/service/NativeClosure.java     |   5 +-
 3 files changed, 121 insertions(+), 145 deletions(-)
 delete mode 100644 server/src/main/java/org/prlprg/service/JITService.java

diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 871f26143..199cf9d51 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -1,24 +1,30 @@
 package org.prlprg.server;
 
+import com.google.common.io.Files;
 import com.google.protobuf.ByteString;
 import io.grpc.Status;
 import io.grpc.stub.StreamObserver;
+import java.io.File;
 import java.io.IOException;
+import java.nio.charset.Charset;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
 import org.prlprg.bc.BCCompiler;
+import org.prlprg.bc.Bc;
+import org.prlprg.bc2c.BC2CCompiler;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.rds.RDSWriter;
-import org.prlprg.service.JITService;
+import org.prlprg.service.NativeClosure;
+import org.prlprg.service.RshCompiler;
 import org.prlprg.session.GNURSession;
-import org.prlprg.sexp.BCodeSXP;
 import org.prlprg.sexp.CloSXP;
 import org.prlprg.sexp.SEXP;
 import org.prlprg.sexp.SEXPs;
 import org.prlprg.util.Pair;
+import org.prlprg.util.Triple;
 
 class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   private static final Logger logger = Logger.getLogger(CompileServer.class.getName());
@@ -26,13 +32,15 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   private @Nullable GNURSession session = null;
   // Cache for all values (including functions)
   private HashMap<ByteString, SEXP> cache = new HashMap<>();
+
   // Cache for byte-code, only for functions. We keep the already serialized code in the cache
   // not the Bc (or BcCodeSXP)
   // Key is (hash, optimisationLevel)
-  private HashMap<Pair<Long, Integer>, ByteString> bcCache = new HashMap<>();
-  private JITService jitService = null; // TODO: merge it with the compile service
-
-  // TODO: cache for native code, which should also include contexts
+  private final HashMap<Pair<Long, Integer>, Pair<Bc, ByteString>> bcCache = new HashMap<>();
+  // Cache for native code.
+  // Key is (hash, bcOpt, ccOpt)
+  private final HashMap<Triple<Long, Integer, Integer>, NativeClosure> nativeCache =
+      new HashMap<>();
 
   // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
   // CompileService.Compile
@@ -62,71 +70,120 @@ public void compile(
 
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
-    if (tier.equals(Messages.Tier.BASELINE)) {
-      // First see if we have the hash in the cache
-      var bcKey = Pair.of(function.getHash(), request.getBcOpt());
-      ByteString cached = bcCache.get(bcKey);
-      if (cached != null) {
-        logger.info("Found " + function.getName() + " in cache. No recompilation.");
+    response.setTier(tier);
+
+    // Cache requests
+    NativeClosure ccCached = null;
+    var nativeKey = Triple.of(function.getHash(), request.getBcOpt(), request.getCcOpt());
+    if (tier.equals(Messages.Tier.OPTIMIZED)) {
+      ccCached = nativeCache.get(nativeKey);
+      if (ccCached != null) {
+        logger.info("Found " + function.getName() + " in native cache. No recompilation.");
+        response.setCode(ccCached.code());
+        response.setConstants(ccCached.constantPool());
+      }
+    }
+
+    Pair<Bc, ByteString> bcCached = null;
+    // We also have a look whether we have a cached bytecode for the native compilation
+    var bcKey = Pair.of(function.getHash(), request.getBcOpt());
+    if (tier.equals((Messages.Tier.BASELINE)) || ccCached == null) {
+      bcCached = bcCache.get(bcKey);
+      if (bcCached != null) {
+        logger.info("Found " + function.getName() + " in bytecode cache. No recompilation.");
+        response.setCode(bcCached.second());
+      }
+    }
+
+    // We do not have the request version in cache
+    // Compile the body if we have it
+    if (!function.hasBody()) {
+      logger.info(
+          "No body sent with the request for function " + function.getName() + ". Cannot compile.");
+      responseObserver.onError(
+          Status.INVALID_ARGUMENT
+              .withDescription("No body sent with the request for function " + function.getName())
+              .asRuntimeException());
+      // TODO: send a request to the client to get the body
+    } else {
+      if ((tier.equals(Messages.Tier.BASELINE) && bcCached == null)
+          || (tier.equals(Messages.Tier.OPTIMIZED) && ccCached == null)) {
+        logger.info(
+            "Compile function "
+                + function.getName()
+                + " to bytecode with optimisation level "
+                + request.getBcOpt()
+                + ": not found in cache.");
         try {
-          response.setCode(cached);
+          var bc = compileBcClosure(function.getBody(), request.getBcOpt());
+          ByteString serializedBc = RDSWriter.writeByteString(SEXPs.bcode(bc));
+          response.setCode(serializedBc);
+          bcCached = Pair.of(bc, serializedBc); // potentially used for the native compilation also
+          // Add it to the cache
+          bcCache.put(bcKey, bcCached);
         } catch (Exception e) {
-          throw new RuntimeException("Impossible to serialize the bytecode");
+          // See
+          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+          // We could have more details using that:
+          // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
+          responseObserver.onError(
+              Status.INTERNAL
+                  .withDescription(
+                      "Cannot bytecode compile function "
+                          + function.getName()
+                          + " ; "
+                          + e.getMessage())
+                  .asRuntimeException());
         }
-      } else {
+      }
+      if (tier.equals(Messages.Tier.OPTIMIZED) && ccCached == null) { // OPTIMIZED tier => native
         logger.info(
             "Compile function "
                 + function.getName()
                 + " with optimisation level "
                 + request.getBcOpt()
+                + " and native level "
+                + request.getCcOpt()
                 + ": not found in cache.");
-        if (function.hasBody()) {
-          try {
-            ByteString serializedBc =
-                compileBcClosure(function.getBody(), request.getBcOpt(), responseObserver);
-            response.setCode(serializedBc);
-            // Add it to the cache
-            bcCache.put(bcKey, serializedBc);
-          } catch (Exception e) {
-            // See
-            // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
-            // We could have more details using that:
-            // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
-            responseObserver.onError(
-                Status.INTERNAL
-                    .withDescription(
-                        "Cannot compile function " + function.getName() + " ; " + e.getMessage())
-                    .asRuntimeException());
-          }
-        } else { // No body
-          // TODO: we need to ask the client for the body
-          logger.info(
-              "No body sent with the request for function "
-                  + function.getName()
-                  + ". Cannot compile.");
+        // At this point, we have already the bytecode, whether we got it from the cache or we
+        // compiled it
+        try {
+          assert bcCached != null;
+          var bc2cCompiler = new BC2CCompiler(bcCached.first());
+          var module = bc2cCompiler.finish();
+          var input = File.createTempFile("cfile", ".c");
+          var f = Files.newWriter(input, Charset.defaultCharset());
+          module.file().writeTo(f);
+          var output = File.createTempFile("ofile", ".o");
+
+          RshCompiler.getInstance(request.getCcOpt())
+              .createBuilder(input.getPath(), output.getPath())
+              .flag("-c")
+              .compile();
+
+          var res = Files.asByteSource(output).read();
+          var serializedConstantPool = RDSWriter.writeByteString(module.constantPool());
+
+          ccCached =
+              new NativeClosure(
+                  ByteString.copyFrom(res), module.topLevelFunName(), serializedConstantPool);
+          nativeCache.put(nativeKey, ccCached);
+          response.setCode(ccCached.code());
+          response.setConstants(ccCached.constantPool());
+        } catch (Exception e) {
+          responseObserver.onError(
+              Status.INTERNAL
+                  .withDescription(
+                      "Cannot native compile function "
+                          + function.getName()
+                          + " ; "
+                          + e.getMessage())
+                  .asRuntimeException());
         }
       }
-    } else { // OPTIMIZED tier => native
-      try {
-        var closure = (CloSXP) RDSReader.readByteString(session, function.getBody());
-        // TODO: rewrite this here to reuse the bytecode cache
-        // TODO: add a native cache
-        var nativeClosure =
-            jitService.execute(function.getName(), closure, request.getBcOpt(), request.getCcOpt());
-        response.setCode(ByteString.copyFrom(nativeClosure.code()));
-        ByteString constantPool = RDSWriter.writeByteString(nativeClosure.constantPool());
-        response.setConstants(constantPool);
-      } catch (Exception e) {
-        responseObserver.onError(
-            Status.INTERNAL
-                .withDescription(
-                    "Cannot compile function " + function.getName() + " ; " + e.getMessage())
-                .asRuntimeException());
-      }
     }
 
     // Send the response
-    response.setTier(tier);
     responseObserver.onNext(response.build());
     responseObserver.onCompleted();
   }
@@ -158,8 +215,6 @@ public void init(
     lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
     session = new GNURSession(convertVersion(RVersion), r_dir, Path.of(lib_dir));
 
-    jitService = new JITService(session);
-
     // TODO: Look into our cache if we have the packages.
     // Request the packages for those we do not have hashes for.
 
@@ -171,12 +226,8 @@ private RVersion convertVersion(Messages.Version version) {
     return new RVersion(version.getMajor(), version.getMinor(), version.getPatch());
   }
 
-  private ByteString compileBcClosure(
-      ByteString body,
-      int optimizationLevel,
-      StreamObserver<Messages.CompileResponse> responseObserver) {
+  private Bc compileBcClosure(ByteString body, int optimizationLevel) {
     SEXP closure = null;
-    ByteString serializedBc = null;
     try {
       assert session != null;
       closure = RDSReader.readByteString(session, body);
@@ -186,21 +237,13 @@ private ByteString compileBcClosure(
     if (closure instanceof CloSXP c) {
       BCCompiler compiler = new BCCompiler(c, session);
       compiler.setOptimizationLevel(optimizationLevel);
-      var res = compiler.compile();
-      if (res.isEmpty()) {
-        throw new RuntimeException("Cannot compile a closure with a browser call");
-      } else {
-        BCodeSXP bc = SEXPs.bcode(res.get());
-
-        try {
-          serializedBc = RDSWriter.writeByteString(bc);
-        } catch (Exception e) {
-          throw new RuntimeException("Impossible to serialize the bytecode");
-        }
+      var bc = compiler.compile();
+      if (bc.isEmpty()) {
+        throw new RuntimeException("Bytecode compilation failed");
       }
+      return bc.get();
     } else {
       throw new RuntimeException("Not a closure");
     }
-    return serializedBc;
   }
 }
diff --git a/server/src/main/java/org/prlprg/service/JITService.java b/server/src/main/java/org/prlprg/service/JITService.java
deleted file mode 100644
index f74736c85..000000000
--- a/server/src/main/java/org/prlprg/service/JITService.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package org.prlprg.service;
-
-import com.google.common.io.Files;
-import java.io.File;
-import java.nio.charset.Charset;
-import java.util.logging.Logger;
-import org.prlprg.bc.BCCompiler;
-import org.prlprg.bc2c.BC2CCompiler;
-import org.prlprg.session.RSession;
-import org.prlprg.sexp.CloSXP;
-
-// TODO: e should rename/refactor all this package and this class (because we also have a
-// CompileService in the server)
-
-public class JITService {
-  private final RSession rsession;
-
-  private static final Logger logger = Logger.getLogger(JITService.class.getName());
-
-  public JITService(RSession rsession) {
-    this.rsession = rsession;
-  }
-
-  public NativeClosure execute(String name, CloSXP closure, int bcOptimization, int ccOptimization)
-      throws Exception {
-    logger.fine(
-        "Compiling closure: "
-            + name
-            + "\n"
-            + closure
-            + "(bcOpt="
-            + bcOptimization
-            + ", ccOpt="
-            + ccOptimization
-            + ")\n");
-
-    var bcCompiler = new BCCompiler(closure, rsession);
-    bcCompiler.setOptimizationLevel(bcOptimization);
-    var bc = bcCompiler.compile().get();
-    var bc2cCompiler = new BC2CCompiler(bc);
-    var module = bc2cCompiler.finish();
-    // var input = new File("/tmp/jit.c");
-    var input = File.createTempFile("cfile", ".c");
-    var f = Files.newWriter(input, Charset.defaultCharset());
-    module.file().writeTo(f);
-    // var output = new File("/tmp/jit.o");
-    var output = File.createTempFile("ofile", ".o");
-
-    RshCompiler.getInstance(ccOptimization)
-        .createBuilder(input.getPath(), output.getPath())
-        .flag("-c")
-        .compile();
-
-    var res = Files.asByteSource(output).read();
-
-    //    if (!input.delete()) {
-    //      throw new IOException("Unable to delete file" + input);
-    //    }
-
-    //    if (!output.delete()) {
-    //      throw new IOException("Unable to delete file" + input);
-    //    }
-
-    return new NativeClosure(res, module.topLevelFunName(), module.constantPool());
-  }
-}
diff --git a/server/src/main/java/org/prlprg/service/NativeClosure.java b/server/src/main/java/org/prlprg/service/NativeClosure.java
index 82248fb7e..15d3b8a35 100644
--- a/server/src/main/java/org/prlprg/service/NativeClosure.java
+++ b/server/src/main/java/org/prlprg/service/NativeClosure.java
@@ -1,6 +1,5 @@
 package org.prlprg.service;
 
-import org.prlprg.sexp.SEXP;
-import org.prlprg.sexp.VectorSXP;
+import com.google.protobuf.ByteString;
 
-public record NativeClosure(byte[] code, String name, VectorSXP<SEXP> constantPool) {}
+public record NativeClosure(ByteString code, String name, ByteString constantPool) {}

From 88e62095029759c4ce78134c531817bb319c711c Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 10 Sep 2024 17:48:08 +0200
Subject: [PATCH 56/80] More readable C function names

---
 .../java/org/prlprg/bc2c/BC2CCompiler.java    | 21 ++++++++++++-------
 .../org/prlprg/server/CompileService.java     |  4 +++-
 .../org/prlprg/bc2c/BC2CCompilerTest.java     |  3 ++-
 3 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java b/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java
index c7b22df02..279b9fccc 100644
--- a/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java
+++ b/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java
@@ -97,6 +97,7 @@ record CompiledClosure(String name, VectorSXP<SEXP> constantPool) {}
 
 class CModule {
   private final List<CFunction> funs = new ArrayList<>();
+  private int funId = 0;
 
   CFunction createFun(String returnType, String name, String args) {
     var fun = new CFunction(returnType, name, args);
@@ -104,11 +105,8 @@ CFunction createFun(String returnType, String name, String args) {
     return fun;
   }
 
-  CompiledClosure compileClosure(Bc bc) {
-    var bcHash = Math.abs(bc.hashCode());
-    var randomSuffix = UUID.randomUUID().toString().substring(0, 8);
-    var name = "f_" + bcHash + "_" + randomSuffix;
-
+  CompiledClosure compileClosure(Bc bc, String baseName) {
+    var name = baseName + "_" + funId++;
     var compiler = new ClosureCompiler(this, name, bc);
     var constants = compiler.compile();
 
@@ -123,13 +121,18 @@ public Iterable<CFunction> funs() {
 public class BC2CCompiler {
   private final CModule module = new CModule();
   private final Bc bc;
+  private final String name; // The name is chosen by the client
 
-  public BC2CCompiler(Bc bc) {
+  public BC2CCompiler(Bc bc, String name) {
     this.bc = bc;
+    // We can have other closures to compile in the same Bc
+    // We will need to generate a unique name for each
+    // This is the base name
+    this.name = name;
   }
 
   public CompiledModule finish() {
-    var compiledClosure = module.compileClosure(bc);
+    var compiledClosure = module.compileClosure(bc, name);
 
     var file = new CFile();
     file.addInclude("runtime.h");
@@ -150,6 +153,7 @@ class ClosureCompiler {
   private static final String VAL_FALSE = "VAL_FALSE";
 
   private final Bc bc;
+  private final String name;
   private final Map<Integer, Constant> constants = new LinkedHashMap<>();
   private final ByteCodeStack stack = new ByteCodeStack();
   private final Set<Integer> labels = new HashSet<>();
@@ -162,6 +166,7 @@ class ClosureCompiler {
 
   public ClosureCompiler(CModule module, String name, Bc bc) {
     this.bc = bc;
+    this.name = name;
     this.module = module;
     this.fun = module.createFun("SEXP", name, "SEXP %s, SEXP %s".formatted(NAME_ENV, NAME_CP));
     this.body = fun.add();
@@ -270,7 +275,7 @@ private void compileMakeClosure(ConstPool.Idx<VecSXP> idx) {
     var cls = bc.consts().get(idx);
 
     if (cls.get(1) instanceof BCodeSXP closureBody) {
-      var compiledClosure = module.compileClosure(closureBody.bc());
+      var compiledClosure = module.compileClosure(closureBody.bc(), name);
       var cpConst = createExtraConstant(compiledClosure.constantPool());
       push(
           "Rsh_native_closure(%s, &%s, %s, %s)"
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 199cf9d51..d9a1dc8ac 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -149,7 +149,9 @@ public void compile(
         // compiled it
         try {
           assert bcCached != null;
-          var bc2cCompiler = new BC2CCompiler(bcCached.first());
+          // Name should be fully decided by the client?
+          var name = function.getName() + "_" + function.getHash();
+          var bc2cCompiler = new BC2CCompiler(bcCached.first(), name);
           var module = bc2cCompiler.finish();
           var input = File.createTempFile("cfile", ".c");
           var f = Files.newWriter(input, Charset.defaultCharset());
diff --git a/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java b/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
index 9ed1b0c47..7de6db8b0 100644
--- a/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
+++ b/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
@@ -279,7 +279,8 @@ <T extends SEXP> TestArtifact<T> compileAndCall(String code) throws Exception {
             .orElseThrow(() -> new RuntimeException("Compilation did not produce byte code"));
 
     try {
-      var bc2c = new BC2CCompiler(bc);
+      var name = "f_" + (bc.hashCode() < 0 ? "n" + -bc.hashCode() : bc.hashCode());
+      var bc2c = new BC2CCompiler(bc, name);
       var module = bc2c.finish();
 
       RDSWriter.writeFile(cpFile, module.constantPool());

From 38dc54603e2c34423001617bc01ca484f89fc456 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 10 Sep 2024 17:54:48 +0200
Subject: [PATCH 57/80] Idea stuff

---
 .idea/code.iml                       |   9 +
 .idea/codeStyles/Project.xml         | 290 +++++++++++++++++++++++++++
 .idea/codeStyles/codeStyleConfig.xml |   5 +
 .idea/compiler.xml                   |  13 ++
 .idea/encodings.xml                  |   7 +
 .idea/google-java-format.xml         |   6 +
 .idea/jarRepositories.xml            |  20 ++
 .idea/misc.xml                       |  62 ++++++
 .idea/modules.xml                    |   8 +
 9 files changed, 420 insertions(+)
 create mode 100644 .idea/code.iml
 create mode 100644 .idea/codeStyles/Project.xml
 create mode 100644 .idea/codeStyles/codeStyleConfig.xml
 create mode 100644 .idea/compiler.xml
 create mode 100644 .idea/encodings.xml
 create mode 100644 .idea/google-java-format.xml
 create mode 100644 .idea/jarRepositories.xml
 create mode 100644 .idea/misc.xml
 create mode 100644 .idea/modules.xml

diff --git a/.idea/code.iml b/.idea/code.iml
new file mode 100644
index 000000000..d6ebd4805
--- /dev/null
+++ b/.idea/code.iml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
new file mode 100644
index 000000000..edd5ef344
--- /dev/null
+++ b/.idea/codeStyles/Project.xml
@@ -0,0 +1,290 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <ScalaCodeStyleSettings>
+      <option name="MULTILINE_STRING_CLOSING_QUOTES_ON_NEW_LINE" value="true" />
+    </ScalaCodeStyleSettings>
+    <codeStyleSettings language="JAVA">
+      <arrangement>
+        <groups>
+          <group>
+            <type>GETTERS_AND_SETTERS</type>
+            <order>KEEP</order>
+          </group>
+          <group>
+            <type>OVERRIDDEN_METHODS</type>
+            <order>KEEP</order>
+          </group>
+        </groups>
+        <rules>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PUBLIC>true</PUBLIC>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PROTECTED>true</PROTECTED>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PRIVATE>true</PRIVATE>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PUBLIC>true</PUBLIC>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PROTECTED>true</PROTECTED>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PRIVATE>true</PRIVATE>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <INITIALIZER_BLOCK>true</INITIALIZER_BLOCK>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PUBLIC>true</PUBLIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PROTECTED>true</PROTECTED>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <FINAL>true</FINAL>
+                  <PRIVATE>true</PRIVATE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PUBLIC>true</PUBLIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PROTECTED>true</PROTECTED>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PACKAGE_PRIVATE>true</PACKAGE_PRIVATE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <FIELD>true</FIELD>
+                  <PRIVATE>true</PRIVATE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <FIELD>true</FIELD>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <INITIALIZER_BLOCK>true</INITIALIZER_BLOCK>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <CONSTRUCTOR>true</CONSTRUCTOR>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <METHOD>true</METHOD>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <METHOD>true</METHOD>
+                  <PRIVATE>true</PRIVATE>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <METHOD>true</METHOD>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <ENUM>true</ENUM>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <INTERFACE>true</INTERFACE>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <CLASS>true</CLASS>
+                  <STATIC>true</STATIC>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <CLASS>true</CLASS>
+              </match>
+            </rule>
+          </section>
+        </rules>
+      </arrangement>
+    </codeStyleSettings>
+  </code_scheme>
+</component>
\ No newline at end of file
diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
new file mode 100644
index 000000000..b9d18bf59
--- /dev/null
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="GoogleStyle" />
+  </state>
+</component>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
new file mode 100644
index 000000000..7fa83999a
--- /dev/null
+++ b/.idea/compiler.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <annotationProcessing>
+      <profile name="Maven default annotation processors profile" enabled="true">
+        <sourceOutputDir name="target/generated-sources/annotations" />
+        <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
+        <outputRelativeToContentRoot value="true" />
+        <module name="r-compile-server" />
+      </profile>
+    </annotationProcessing>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/encodings.xml b/.idea/encodings.xml
new file mode 100644
index 000000000..2c23a594f
--- /dev/null
+++ b/.idea/encodings.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/server/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/server/src/main/resources" charset="UTF-8" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/google-java-format.xml b/.idea/google-java-format.xml
new file mode 100644
index 000000000..8b57f4527
--- /dev/null
+++ b/.idea/google-java-format.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GoogleJavaFormatSettings">
+    <option name="enabled" value="true" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
new file mode 100644
index 000000000..712ab9d98
--- /dev/null
+++ b/.idea/jarRepositories.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RemoteRepositoriesConfiguration">
+    <remote-repository>
+      <option name="id" value="central" />
+      <option name="name" value="Central Repository" />
+      <option name="url" value="https://repo.maven.apache.org/maven2" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="central" />
+      <option name="name" value="Maven Central repository" />
+      <option name="url" value="https://repo1.maven.org/maven2" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="jboss.community" />
+      <option name="name" value="JBoss Community repository" />
+      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
+    </remote-repository>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 000000000..c7b82a580
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/server/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="NullableNotNullManager">
+    <option name="myDefaultNullable" value="javax.annotation.Nullable" />
+    <option name="myDefaultNotNull" value="org.jetbrains.annotations.NotNull" />
+    <option name="myNullables">
+      <value>
+        <list size="16">
+          <item index="0" class="java.lang.String" itemvalue="org.jspecify.annotations.Nullable" />
+          <item index="1" class="java.lang.String" itemvalue="com.android.annotations.Nullable" />
+          <item index="2" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.Nullable" />
+          <item index="3" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNullable" />
+          <item index="4" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableDecl" />
+          <item index="5" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
+          <item index="6" class="java.lang.String" itemvalue="androidx.annotation.Nullable" />
+          <item index="7" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.Nullable" />
+          <item index="8" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.Nullable" />
+          <item index="9" class="java.lang.String" itemvalue="android.support.annotation.Nullable" />
+          <item index="10" class="java.lang.String" itemvalue="jakarta.annotation.Nullable" />
+          <item index="11" class="java.lang.String" itemvalue="javax.annotation.CheckForNull" />
+          <item index="12" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
+          <item index="13" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.Nullable" />
+          <item index="14" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableType" />
+          <item index="15" class="java.lang.String" itemvalue="io.reactivex.annotations.Nullable" />
+        </list>
+      </value>
+    </option>
+    <option name="myNotNulls">
+      <value>
+        <list size="16">
+          <item index="0" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNonNull" />
+          <item index="1" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.NonNull" />
+          <item index="2" class="java.lang.String" itemvalue="org.jspecify.annotations.NonNull" />
+          <item index="3" class="java.lang.String" itemvalue="jakarta.annotation.Nonnull" />
+          <item index="4" class="java.lang.String" itemvalue="io.reactivex.annotations.NonNull" />
+          <item index="5" class="java.lang.String" itemvalue="androidx.annotation.NonNull" />
+          <item index="6" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullType" />
+          <item index="7" class="java.lang.String" itemvalue="lombok.NonNull" />
+          <item index="8" class="java.lang.String" itemvalue="android.support.annotation.NonNull" />
+          <item index="9" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.NonNull" />
+          <item index="10" class="java.lang.String" itemvalue="com.android.annotations.NonNull" />
+          <item index="11" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.NonNull" />
+          <item index="12" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullDecl" />
+          <item index="13" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
+          <item index="14" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
+          <item index="15" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.NonNull" />
+        </list>
+      </value>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="22" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 000000000..23968dc67
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/code.iml" filepath="$PROJECT_DIR$/.idea/code.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

From 6aee69a017b45b7b8189a6027e6541bc24e7078b Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 10 Sep 2024 18:03:17 +0200
Subject: [PATCH 58/80] Clean the idea config so that it works again

---
 .idea/code.iml     | 9 ---------
 .idea/compiler.xml | 3 +++
 .idea/misc.xml     | 1 +
 .idea/modules.xml  | 8 --------
 4 files changed, 4 insertions(+), 17 deletions(-)
 delete mode 100644 .idea/code.iml
 delete mode 100644 .idea/modules.xml

diff --git a/.idea/code.iml b/.idea/code.iml
deleted file mode 100644
index d6ebd4805..000000000
--- a/.idea/code.iml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 7fa83999a..a19107b5e 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -9,5 +9,8 @@
         <module name="r-compile-server" />
       </profile>
     </annotationProcessing>
+    <bytecodeTargetLevel>
+      <module name="code" target="22" />
+    </bytecodeTargetLevel>
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index c7b82a580..616fc9014 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -4,6 +4,7 @@
   <component name="MavenProjectsManager">
     <option name="originalFiles">
       <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
         <option value="$PROJECT_DIR$/server/pom.xml" />
       </list>
     </option>
diff --git a/.idea/modules.xml b/.idea/modules.xml
deleted file mode 100644
index 23968dc67..000000000
--- a/.idea/modules.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/code.iml" filepath="$PROJECT_DIR$/.idea/code.iml" />
-    </modules>
-  </component>
-</project>
\ No newline at end of file

From 4833aa179c3c0e8f7b05b4e7110c48f8eb90d123 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 23 Sep 2024 15:47:16 +0200
Subject: [PATCH 59/80] Native code caching

---
 client/rsh/src/compiler.cpp                                | 5 +++--
 client/rsh/test6.R                                         | 5 +++++
 server/src/main/java/org/prlprg/server/CompileService.java | 1 +
 server/src/main/java/org/prlprg/service/RshCompiler.java   | 4 ++--
 4 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index b1bd7657c..a48789f93 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -183,10 +183,11 @@ SEXP compile(SEXP closure, SEXP options) {
 
   SEXP body = nullptr;
   void * fun_ptr = nullptr;
+  std::string name = opts.name + "_" + std::to_string(compiled_fun.hash()) + "_0";
   // Native or bytecode?
   if(opts.tier == protocol::Tier::OPTIMIZED) {
-    fun_ptr = insert_into_jit(opts.name.c_str(), compiled_fun);
-    SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, opts.name.c_str(), compiled_fun));
+    fun_ptr = insert_into_jit(name.c_str(), compiled_fun);
+    SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, name.c_str(), compiled_fun));
     body = PROTECT(create_wrapper_body(closure, c_cp));
   }
   else if(opts.tier == protocol::Tier::BASELINE) {
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index e16dc8e30..bd38b2340 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -34,4 +34,9 @@ f <- function(x) {
 # body changed so it should be recompiled
 rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
 
+stopifnot(f(5) == 8)
+
+# Now native compilation
+rsh::rsh_compile(f, list(tier = "native", bc_opt = 3L, cc_opt = 3L))
+
 stopifnot(f(5) == 8)
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index d9a1dc8ac..49d056271 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -71,6 +71,7 @@ public void compile(
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
     response.setTier(tier);
+    response.setHash(function.getHash());
 
     // Cache requests
     NativeClosure ccCached = null;
diff --git a/server/src/main/java/org/prlprg/service/RshCompiler.java b/server/src/main/java/org/prlprg/service/RshCompiler.java
index a358217ef..c9ea52281 100644
--- a/server/src/main/java/org/prlprg/service/RshCompiler.java
+++ b/server/src/main/java/org/prlprg/service/RshCompiler.java
@@ -15,9 +15,9 @@ public class RshCompiler {
   //  and upon server instantiation, copy it to some temp directory
   //  and precompile the header file (if needed)
   private static final Path RSH_INCLUDE_PATH =
-      Paths.get("../client/rsh/src/bc2c").normalize().toAbsolutePath();
+      Paths.get("client/rsh/src/bc2c").normalize().toAbsolutePath();
   private static final Path R_INCLUDE_PATH =
-      Paths.get("../external/R/include").normalize().toAbsolutePath();
+      Paths.get("external/R/include").normalize().toAbsolutePath();
 
   // TODO: which ones are needed?
   private static final List<String> COMMON_COMPILER_FLAGS =

From fe14491d3ed1c742112b04b7d83c1c9bb0217c11 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 23 Sep 2024 15:52:04 +0200
Subject: [PATCH 60/80] .gitignore

---
 .idea/.gitignore | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 .idea/.gitignore

diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 000000000..13566b81b
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

From c674593965c8f51b091a411082958bf1e0c4d721 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 24 Sep 2024 17:40:51 +0200
Subject: [PATCH 61/80] Fix tests

---
 client/rsh/test3.R                              | 15 ---------------
 client/rsh/test4.R                              | 17 -----------------
 client/rsh/test6.R                              |  4 ++--
 client/rsh/test7.R                              | 13 -------------
 external/R-debug                                |  1 -
 .../main/java/org/prlprg/bc2c/BC2CCompiler.java |  2 +-
 6 files changed, 3 insertions(+), 49 deletions(-)
 delete mode 100644 client/rsh/test3.R
 delete mode 100644 client/rsh/test4.R
 delete mode 100644 client/rsh/test7.R
 delete mode 160000 external/R-debug

diff --git a/client/rsh/test3.R b/client/rsh/test3.R
deleted file mode 100644
index de0c8a0f1..000000000
--- a/client/rsh/test3.R
+++ /dev/null
@@ -1,15 +0,0 @@
-dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
-
-f <- function(x) {
-  y <- x + 42
-  y + x
-}
-
-rsh::rsh_compile(f)
-print(f)
-
-str(compiler::disassemble(f))
-
-f(5)
-rm(f)
-gc()
diff --git a/client/rsh/test4.R b/client/rsh/test4.R
deleted file mode 100644
index 392d9423d..000000000
--- a/client/rsh/test4.R
+++ /dev/null
@@ -1,17 +0,0 @@
-dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
-
-
-f <- function(x) {
-  y <- x + 42
-  y + x
-}
-
-rsh::rsh_jit_enable()
-print(f)
-
-f(5)
-f(5)
-f(5)
-
-print(f)
-.Internal(inspect(f))
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index bd38b2340..b81ccb629 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -1,8 +1,8 @@
-dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
-
 rsh::rsh_jit_enable()
 rsh::rsh_jit_disable()
 
+rsh::init_client(port=8979L)
+
 f <- function(x) {
   y <- x + 42
   y + x
diff --git a/client/rsh/test7.R b/client/rsh/test7.R
deleted file mode 100644
index 15a6b90f6..000000000
--- a/client/rsh/test7.R
+++ /dev/null
@@ -1,13 +0,0 @@
-dyn.load("../../external/R/library/rsh/libs/rsh.so", local = FALSE)
-
-f <- function (n) {
-  c(1,2) + n
-}
-
-rsh <- rsh:::rsh_cmpfun(f, options=list(optimize=3))
-
-f(1) == c(2,3)
-stopifnot(f(1) == c(2,3))
-
-g <- function() .External2("Rsh_call_trampoline", 1)
-g()
diff --git a/external/R-debug b/external/R-debug
deleted file mode 160000
index 687361ae5..000000000
--- a/external/R-debug
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 687361ae5abf33eae7d4a8884c23656ce3f1b187
diff --git a/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java b/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java
index eef0b3f71..84d27f88f 100644
--- a/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java
+++ b/server/src/main/java/org/prlprg/bc2c/BC2CCompiler.java
@@ -215,7 +215,7 @@ private String compileMakeClosure(InstrBuilder builder, ConstPool.Idx<VecSXP> id
     var cls = bc.consts().get(idx);
 
     if (cls.get(1) instanceof BCodeSXP closureBody) {
-      var compiledClosure = module.compileClosure(closureBody.bc());
+      var compiledClosure = module.compileClosure(closureBody.bc(), name);
       var cpConst = createExtraConstant(compiledClosure.constantPool());
       return builder
           .args(constantSXP(idx), "&" + compiledClosure.name(), constantSXP(cpConst))

From ce18840750f92e0a9f77fd3d4bf2003dd3362df8 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 24 Sep 2024 17:46:54 +0200
Subject: [PATCH 62/80] Normal port for test 6

---
 client/rsh/test6.R | 2 --
 1 file changed, 2 deletions(-)

diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index b81ccb629..13ff2ea6a 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -1,8 +1,6 @@
 rsh::rsh_jit_enable()
 rsh::rsh_jit_disable()
 
-rsh::init_client(port=8979L)
-
 f <- function(x) {
   y <- x + 42
   y + x

From 3f9031be154c78938149a6ce93f21eb1137839bf Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 25 Sep 2024 14:56:49 +0200
Subject: [PATCH 63/80] Add protobuf and grpc in the devcontainer

---
 .devcontainer/Dockerfile        | 5 ++---
 .devcontainer/devcontainer.json | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index c891e538b..390bebeaf 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -74,6 +74,5 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get -y remove --purge $GNUR_BUILD_DEPENDE
 RUN DEBIAN_FRONTEND=noninteractive apt-get -y install --no-install-recommends gfortran
 RUN DEBIAN_FRONTEND=noninteractive apt-get -y autoremove
 
-# [Optional] Uncomment this section to install additional OS packages.
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+     && apt-get -y install --no-install-recommends protobuf-compiler protobuf-compiler-grpc 
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 144ad0d4e..4acc92b8d 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -3,7 +3,7 @@
     "dockerfile": "./Dockerfile",
     "context": "."
   },
-  features: {
+  "features": {
     "ghcr.io/devcontainers/features/java:1": {
       "installMaven": "true"
     }

From 71f69abc6b52cec04dc30fddbf30d1d9713936e5 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 27 Sep 2024 18:01:13 +0200
Subject: [PATCH 64/80] Abstract symbol generation

---
 client/rsh/src/compiler.cpp                          |  7 ++++++-
 client/rsh/test6.R                                   | 12 ++++++------
 .../main/java/org/prlprg/server/CompileService.java  |  6 +++++-
 3 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 7bbbdcdd5..f390281b6 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -160,6 +160,11 @@ CompilerOptions CompilerOptions::from_list(SEXP listsxp) {
   return opts;
 }
 
+
+std::string genSymbol(const std:;string& name, uint64_t hash, int index) {
+  return name + "_" + std::to_string(hash) + "_" + std::to_string(index);
+}
+
 SEXP compile(SEXP closure, SEXP options) {
   if (!RSH_JIT_FUN_PTR) {
     Rf_error("The package was not initialized");
@@ -181,7 +186,7 @@ SEXP compile(SEXP closure, SEXP options) {
 
   SEXP body = nullptr;
   void * fun_ptr = nullptr;
-  std::string name = opts.name + "_" + std::to_string(compiled_fun.hash()) + "_0";
+  std::string name = genSymbol(opts.name, compiled_fun.hash(), 0);
   // Native or bytecode?
   if(opts.tier == protocol::Tier::OPTIMIZED) {
     fun_ptr = insert_into_jit(name.c_str(), compiled_fun);
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index 13ff2ea6a..9c6c91279 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -25,16 +25,16 @@ rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
 
 stopifnot(f(5) == 52)
 
-f <- function(x) {
+g <- function(x) {
     x + 3
 }
 
 # body changed so it should be recompiled
-rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
-
-stopifnot(f(5) == 8)
+# rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
+# str(compiler::disassemble(f))
+# stopifnot(f(5) == 8)
 
 # Now native compilation
-rsh::rsh_compile(f, list(tier = "native", bc_opt = 3L, cc_opt = 3L))
+rsh::rsh_compile(g, list(tier = "native", bc_opt = 3L, cc_opt = 3L))
 
-stopifnot(f(5) == 8)
\ No newline at end of file
+stopifnot(g(5) == 8)
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 49d056271..b8d0bef3e 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -42,6 +42,10 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
   private final HashMap<Triple<Long, Integer, Integer>, NativeClosure> nativeCache =
       new HashMap<>();
 
+  private static String genSymbol(Messages.Function function) {
+    return function.getName() + "_" + function.getHash();
+  }
+
   // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
   // CompileService.Compile
   @Override
@@ -151,7 +155,7 @@ public void compile(
         try {
           assert bcCached != null;
           // Name should be fully decided by the client?
-          var name = function.getName() + "_" + function.getHash();
+          var name = genSymbol(function);
           var bc2cCompiler = new BC2CCompiler(bcCached.first(), name);
           var module = bc2cCompiler.finish();
           var input = File.createTempFile("cfile", ".c");

From df2edd95b0ef95ae1d4410fda8a68961c5fd1b5c Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Mon, 30 Sep 2024 17:25:38 +0200
Subject: [PATCH 65/80] Cache and native compilation now work

---
 client/rsh/src/client.cpp                     | 14 +--------
 client/rsh/src/client.hpp                     |  6 ----
 client/rsh/src/compiler.cpp                   | 29 ++++++++++++++-----
 client/rsh/test6.R                            | 28 ++++++++++--------
 .../org/prlprg/server/CompileService.java     |  2 +-
 5 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 3cf65add2..774550a4e 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -61,13 +61,7 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
   // We replace the body of a function with its compiled version so it would not make
   //sense to compute its hash again, except if its body has changed.
   auto hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
-  if(compiled_functions.find(options.name) != compiled_functions.end() && compiled_functions[options.name].second == hash) {
-    request.mutable_function()->set_hash(compiled_functions[options.name].first);
-  }
-  else {
-    request.mutable_function()->set_hash(hash);
-    compiled_functions[options.name] = std::make_pair(hash, 0);
-  }
+  request.mutable_function()->set_hash(hash);
 
   grpc::ClientContext context;
   CompileResponse response;
@@ -131,10 +125,4 @@ SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
   return R_NilValue;
 }
 
-void Client::mark_compiled_function(const std::string& name, SEXP closure) {
-  auto bytes = rsh::serialize(closure);
-  Client::get_client()->compiled_functions[name].second = xxh::xxhash3<64>(bytes);
-}
-
-
 } // namespace rsh
diff --git a/client/rsh/src/client.hpp b/client/rsh/src/client.hpp
index bb3e14bdd..474b805fe 100644
--- a/client/rsh/src/client.hpp
+++ b/client/rsh/src/client.hpp
@@ -26,11 +26,6 @@ class Client {
 
   // For it to be able to access the client instance
   friend SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
-
-  // Remember the compiled functions with their hash both when
-  // they are not yet compiled, and when they are.
-  std::unordered_map<std::string, std::pair<uint64_t, uint64_t>> compiled_functions;
-
 public:
   Client(std::shared_ptr<grpc::Channel> channel, std::vector<std::string> installed_packages);
 
@@ -40,7 +35,6 @@ class Client {
 
   static SEXP make_client(SEXP address, SEXP port, SEXP installed_packages);
   static Client* get_client();
-  static void mark_compiled_function(const std::string& name, SEXP closure);
 };
 
 SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index f390281b6..b89b30296 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -36,7 +36,23 @@ namespace rsh {
 SEXP RSH_JIT_FUN_PTR = Rf_install("RSH_JIT_FUN_PTR");
 
 static std::variant<protocol::CompileResponse, std::string> compile_closure(SEXP closure, CompilerOptions options) {
-  auto closure_bytes = rsh::serialize(closure);
+  // If a function has already been compiled to native code
+  if(Rf_asLogical(is_compiled(closure))) {
+    return "Function already compiled";
+  }
+
+  std::vector<uint8_t> closure_bytes;
+
+  if(IS_BYTECODE(BODY(closure))) {
+    // Build the closure AST to get the correct hash
+    // The AST is the first element in the constant pool of the BCODESXP
+    SEXP body = BODY_EXPR(closure);
+    auto ast_clos = Rf_mkCLOSXP(FORMALS(closure), body, CLOENV(closure));
+    closure_bytes = rsh::serialize(ast_clos);
+  }
+  else {
+   closure_bytes = rsh::serialize(closure);
+  }
   auto client = rsh::Client::get_client();
   return client->remote_compile(closure_bytes, options);
 }
@@ -161,8 +177,8 @@ CompilerOptions CompilerOptions::from_list(SEXP listsxp) {
 }
 
 
-std::string genSymbol(const std:;string& name, uint64_t hash, int index) {
-  return name + "_" + std::to_string(hash) + "_" + std::to_string(index);
+std::string genSymbol(uint64_t hash, int index) {
+  return "gen_" + std::to_string(hash) + "_" + std::to_string(index);
 }
 
 SEXP compile(SEXP closure, SEXP options) {
@@ -186,7 +202,7 @@ SEXP compile(SEXP closure, SEXP options) {
 
   SEXP body = nullptr;
   void * fun_ptr = nullptr;
-  std::string name = genSymbol(opts.name, compiled_fun.hash(), 0);
+  std::string name = genSymbol(compiled_fun.hash(), 0);
   // Native or bytecode?
   if(opts.tier == protocol::Tier::OPTIMIZED) {
     fun_ptr = insert_into_jit(name.c_str(), compiled_fun);
@@ -236,10 +252,7 @@ SEXP compile(SEXP closure, SEXP options) {
   else {
     UNPROTECT(1);
   }
-  // To be able to see if the body of a closure is the result of a JIT compilation
-  // TODO: don't mark it again if we know that the compile server is sending the same code again.
-  // TODO: does it still work when not replacing the body in place?
-  Client::mark_compiled_function(opts.name, closure);
+
 
   return closure;
 }
diff --git a/client/rsh/test6.R b/client/rsh/test6.R
index 9c6c91279..ebdffd809 100644
--- a/client/rsh/test6.R
+++ b/client/rsh/test6.R
@@ -1,40 +1,44 @@
 rsh::rsh_jit_enable()
 rsh::rsh_jit_disable()
 
+
+cat("TEST 1\n")
 f <- function(x) {
   y <- x + 42
   y + x
 }
-
 print(f)
-
 rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
 print(f)
-
 print(f(5))
-
 stopifnot(f(5) == 52)
 
+cat("TEST 2\n")
 # f should be in the compile cache now.
 rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
-
+print(f)
+.Internal(inspect(f))
+print(f(5))
 stopifnot(f(5) == 52)
 
+cat("TEST 3\n")
 # another opt level so it should be recompiled
 rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
-
 stopifnot(f(5) == 52)
 
-g <- function(x) {
+
+cat("TEST 4\n")
+f <- function(x) {
     x + 3
 }
 
 # body changed so it should be recompiled
-# rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
-# str(compiler::disassemble(f))
-# stopifnot(f(5) == 8)
+rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 2L))
+#str(compiler::disassemble(f))
+stopifnot(f(5) == 8)
 
+cat("TEST 5\n")
 # Now native compilation
-rsh::rsh_compile(g, list(tier = "native", bc_opt = 3L, cc_opt = 3L))
+rsh::rsh_compile(f, list(tier = "native", bc_opt = 3L, cc_opt = 3L))
 
-stopifnot(g(5) == 8)
\ No newline at end of file
+stopifnot(f(5) == 8)
\ No newline at end of file
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index b8d0bef3e..68ce31b6c 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -43,7 +43,7 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
       new HashMap<>();
 
   private static String genSymbol(Messages.Function function) {
-    return function.getName() + "_" + function.getHash();
+    return "gen_" + function.getHash();
   }
 
   // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980

From c5a76e197097c8f145dbce18c8d0681c78a04e17 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 1 Oct 2024 16:53:08 +0200
Subject: [PATCH 66/80] Session tests now use the R that is included in
 external/R

---
 .../java/org/prlprg/service/RshCompiler.java  |  1 -
 .../java/org/prlprg/session/GNURSession.java  | 47 ++++++++++++-------
 .../test/java/org/prlprg/GNURBasedTests.java  |  1 +
 .../test/java/org/prlprg/RDSSnapshotTest.java |  1 +
 .../org/prlprg/bc2c/BC2CCompilerTest.java     |  2 +-
 .../org/prlprg/rsession/GNURSessionTest.java  | 32 ++++---------
 .../java/org/prlprg/util/GNURFactory.java     |  2 +-
 7 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/server/src/main/java/org/prlprg/service/RshCompiler.java b/server/src/main/java/org/prlprg/service/RshCompiler.java
index c9ea52281..4244f9eb4 100644
--- a/server/src/main/java/org/prlprg/service/RshCompiler.java
+++ b/server/src/main/java/org/prlprg/service/RshCompiler.java
@@ -58,7 +58,6 @@ public static RshCompiler getInstance(int optimizationLevel) {
     }
     flags.add("-O" + optimizationLevel);
 
-    // TODO: cache
     return new RshCompiler(flags);
   }
 
diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index a0ed219f3..98527a656 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -71,8 +71,8 @@ public ImmutableList<String> RFunTab() {
 public class GNURSession implements RSession {
   private URI cranMirror;
   private org.prlprg.RVersion RVersion;
-  private Path RDir;
-  private Path RLibraries;
+  private final Path RDir;
+  private final Path RLibraries;
 
   private @Nullable BaseEnvSXP baseEnv = null;
   private @Nullable NamespaceEnvSXP baseNamespace = null;
@@ -101,6 +101,13 @@ public void setCranMirror(URI uri) {}
 
   // We should also handle installation of a package from a GitHub repo?
   public void loadPackage(String name, String version) {
+    var pkgPath = RLibraries.resolve(name);
+    var pkgDir = pkgPath.toFile();
+    // Check if package is installed and if not install it
+    if (!pkgDir.exists() || !pkgDir.isDirectory()) {
+      installPackage(name);
+    }
+
     DESCRIPTION description = getDescription(name);
 
     String installedVersion = description.getVersion();
@@ -131,25 +138,31 @@ public void loadPackage(String name, String version) {
     }
   }
 
-  private DESCRIPTION getDescription(String name) {
+  private void installPackage(String name) {
     var pkgPath = RLibraries.resolve(name);
     var pkgDir = pkgPath.toFile();
-    if (!pkgDir.exists() || !pkgDir.isDirectory()) {
-      // Check if package is installed and if not install it
-      try {
-        ProcessBuilder processBuilder =
-            new ProcessBuilder(
-                "Rscript", "-e", "install.packages('" + name + "', repos='" + cranMirror + "')");
-        processBuilder.inheritIO();
-        Process process = processBuilder.start();
-        int exitCode = process.waitFor();
-        if (exitCode != 0) {
-          throw new RuntimeException("Failed to install package " + name);
-        }
-      } catch (IOException | InterruptedException e) {
-        throw new RuntimeException("Failed to install package " + name, e);
+
+    var RScript = RDir.resolve("bin/Rscript");
+    try {
+      ProcessBuilder processBuilder =
+          new ProcessBuilder(
+              RScript.toString(),
+              "-e",
+              "install.packages('" + name + "', repos='" + cranMirror + "')");
+      processBuilder.inheritIO();
+      Process process = processBuilder.start();
+      int exitCode = process.waitFor();
+      if (exitCode != 0) {
+        throw new RuntimeException("Failed to install package " + name);
       }
+    } catch (IOException | InterruptedException e) {
+      throw new RuntimeException("Failed to install package " + name, e);
     }
+  }
+
+  private DESCRIPTION getDescription(String name) {
+    var pkgPath = RLibraries.resolve(name);
+    var pkgDir = pkgPath.toFile();
 
     Path descriptionFile = pkgPath.resolve("DESCRIPTION");
     DESCRIPTION description;
diff --git a/server/src/test/java/org/prlprg/GNURBasedTests.java b/server/src/test/java/org/prlprg/GNURBasedTests.java
index 1fe93ec58..ae02ad40c 100644
--- a/server/src/test/java/org/prlprg/GNURBasedTests.java
+++ b/server/src/test/java/org/prlprg/GNURBasedTests.java
@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.AfterAll;
 import org.prlprg.rsession.TestRSession;
+import org.prlprg.session.RSession;
 import org.prlprg.util.GNUR;
 import org.prlprg.util.GNURFactory;
 
diff --git a/server/src/test/java/org/prlprg/RDSSnapshotTest.java b/server/src/test/java/org/prlprg/RDSSnapshotTest.java
index f3128659b..2ddf9e767 100644
--- a/server/src/test/java/org/prlprg/RDSSnapshotTest.java
+++ b/server/src/test/java/org/prlprg/RDSSnapshotTest.java
@@ -5,6 +5,7 @@
 import java.nio.file.Path;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.rds.RDSWriter;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.SEXP;
 
 public abstract class RDSSnapshotTest<T> extends SnapshotTest<T> {
diff --git a/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java b/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
index 32c4e685f..1f07c2324 100644
--- a/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
+++ b/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
@@ -324,7 +324,7 @@ TestArtifact compileAndCall(String code) throws Exception {
 
     var funCode = "function() {" + code + "}";
     var closure = (CloSXP) R.eval(funCode);
-    var ast2bc = new BCCompiler(closure, rsession);
+    var ast2bc = new BCCompiler(closure, Rsession);
 
     // FIXME: just for now as we do not support guards
     ast2bc.setOptimizationLevel(3);
diff --git a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index b229d7c67..f3c0a33e0 100644
--- a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -9,15 +9,14 @@
 import org.prlprg.session.GNURSession;
 
 public class GNURSessionTest {
-  private static final String R_HOME = System.getenv("R_HOME");
+  private static final Path RDir = Path.of("../external/R/");
+  // TODO: rather create a temporary library directory for the tests?
+  private static final Path libDir = Path.of("../external/R/library/");
   @TempDir Path tempDir;
 
   @Test
   public void testReadPackageDatabase() throws IOException {
-    var r_dir = Path.of("/usr/lib/R/");
-    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
-    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
-    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+    var session = new GNURSession(RVersion.LATEST_AWARE, RDir, libDir);
 
     session.loadPackage("yaml", "2.3.10");
 
@@ -28,8 +27,7 @@ public void testReadPackageDatabase() throws IOException {
 
   @Test
   public void testLoadBase() throws IOException {
-    var p = Path.of("/usr/lib/R/");
-    var session = new GNURSession(RVersion.LATEST_AWARE, p, null);
+    var session = new GNURSession(RVersion.LATEST_AWARE, RDir, null);
     session.loadBase();
 
     Assertions.assertFalse(session.baseNamespace().isEmpty());
@@ -37,10 +35,7 @@ public void testLoadBase() throws IOException {
 
   @Test
   public void testVersionMismatch() {
-    var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
-    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
-    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+    var session = new GNURSession(RVersion.LATEST_AWARE, RDir, libDir);
 
     Assertions.assertThrows(
         RuntimeException.class,
@@ -51,10 +46,7 @@ public void testVersionMismatch() {
 
   @Test
   public void testLoadNonInstalledPackage() throws IOException, InterruptedException {
-    var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
-    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
-    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+    var session = new GNURSession(RVersion.LATEST_AWARE, RDir, libDir);
 
     // Assuming "nonexistentpkg" is not installed
     Assertions.assertThrows(
@@ -66,10 +58,7 @@ public void testLoadNonInstalledPackage() throws IOException, InterruptedExcepti
 
   @Test
   public void testRetrieveNamespaceAfterLoadingPackage() throws IOException {
-    var r_dir = Path.of("/usr/lib/R/");
-    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
-    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
-    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+    var session = new GNURSession(RVersion.LATEST_AWARE, RDir, libDir);
 
     session.loadPackage("yaml", "2.3.10");
 
@@ -80,10 +69,7 @@ public void testRetrieveNamespaceAfterLoadingPackage() throws IOException {
 
   @Test
   public void testMissingDescriptionFile() {
-    var r_dir = Path.of("/usr/local/lib/R/");
-    var lib_dir = "~/R/x86_64-pc-linux-gnu-library/4.4/";
-    lib_dir = lib_dir.replaceFirst("^~", System.getProperty("user.home"));
-    var session = new GNURSession(RVersion.LATEST_AWARE, r_dir, Path.of(lib_dir));
+    var session = new GNURSession(RVersion.LATEST_AWARE, RDir, libDir);
 
     // Assuming "pkgwithnomissingdesc" has no DESCRIPTION file
     Assertions.assertThrows(
diff --git a/server/src/test/java/org/prlprg/util/GNURFactory.java b/server/src/test/java/org/prlprg/util/GNURFactory.java
index 77b91b53d..31e2cadcd 100644
--- a/server/src/test/java/org/prlprg/util/GNURFactory.java
+++ b/server/src/test/java/org/prlprg/util/GNURFactory.java
@@ -9,9 +9,9 @@
 import java.util.function.Supplier;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.NotThreadSafe;
-import org.prlprg.RSession;
 import org.prlprg.rds.RDSReader;
 import org.prlprg.rds.RDSWriter;
+import org.prlprg.session.RSession;
 import org.prlprg.sexp.SEXP;
 
 public class GNURFactory {

From 112403e77cc1c8ae1a97ed953b6a9ac214d5f2f8 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 1 Oct 2024 17:34:50 +0200
Subject: [PATCH 67/80] Fix BC2C tests.

---
 README.md                                           |  2 ++
 external/R                                          |  2 +-
 .../main/java/org/prlprg/service/RshCompiler.java   | 13 +++++++++++--
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 66da8e329..6aaff9067 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,8 @@ If the dev container is too slow, you can also setup on the host machine. To do
   - **Solution:** ensure you have a Java 22 JDK installed, then run `JAVA_HOME=<path to JDK 22> mvn …`
     - e.g. if using IntelliJ on macOS, openJDK 22, set `JAVA_HOME=~/Library/Java/JavaVirtualMachines/openjdk-22/Contents/Home`
     - In the devcontainer, `JAVA_HOME=/usr/lib/jvm/jdk`
+- **Problem:** some R symbols are not visible when JIT-compiling.
+  - **Solution:** make sure that `external/R` is up-to-date with `git submodule update --init --recursive` and check if it is the right branch, `RSH-4-3-2`. 
 
 If you have a different issue than the above, [report it on GitHub](https://github.com/PRL-PRG/r-compile-server/issues/new/choose).
 
diff --git a/external/R b/external/R
index 5fb4b8dc0..f5486e806 160000
--- a/external/R
+++ b/external/R
@@ -1 +1 @@
-Subproject commit 5fb4b8dc05bb8f38e1e34267a0a99f08eebbb905
+Subproject commit f5486e8068ca9a1bd91ca44e7650f89a2fe17047
diff --git a/server/src/main/java/org/prlprg/service/RshCompiler.java b/server/src/main/java/org/prlprg/service/RshCompiler.java
index 4244f9eb4..badb718fb 100644
--- a/server/src/main/java/org/prlprg/service/RshCompiler.java
+++ b/server/src/main/java/org/prlprg/service/RshCompiler.java
@@ -10,14 +10,23 @@
 public class RshCompiler {
   private static final Logger logger = Logger.getLogger(RshCompiler.class.getName());
 
+  // Make it work whether we run it  from the server directory or from the root of the project
+  private static Path baseDirectory = Paths.get("").toAbsolutePath();
+
+  static {
+    if (baseDirectory.endsWith("server")) {
+      baseDirectory = baseDirectory.getParent();
+    }
+  }
+
   // TODO: this is just temporary
   //  what we need is to keep this in the resources, versioned by R version
   //  and upon server instantiation, copy it to some temp directory
   //  and precompile the header file (if needed)
   private static final Path RSH_INCLUDE_PATH =
-      Paths.get("client/rsh/src/bc2c").normalize().toAbsolutePath();
+      baseDirectory.resolve("client/rsh/src/bc2c").normalize().toAbsolutePath();
   private static final Path R_INCLUDE_PATH =
-      Paths.get("external/R/include").normalize().toAbsolutePath();
+      baseDirectory.resolve("external/R/include").normalize().toAbsolutePath();
 
   // TODO: which ones are needed?
   private static final List<String> COMMON_COMPILER_FLAGS =

From 2f19c345e65e3056f2001dd8a72398fcc1d3e6cf Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 4 Oct 2024 11:41:09 +0200
Subject: [PATCH 68/80] FIX: the body wrapper needs to have a reference to its
 closure

---
 client/rsh/R/rsh.R                            |    4 +
 client/rsh/src/Makevars                       |    7 +-
 client/rsh/src/bc2c/runtime_impl.h            |    2 +-
 client/rsh/src/client.cpp                     |    4 +-
 client/rsh/src/compiler.cpp                   |   18 +-
 client/rsh/src/compiler.hpp                   |    6 +-
 client/rsh/src/protocol.pb.cc                 | 1771 ---------------
 client/rsh/src/protocol.pb.h                  | 1938 -----------------
 server/.jqwik-database                        |  Bin 4 -> 1086 bytes
 .../org/prlprg/server/CompileService.java     |   25 +-
 10 files changed, 43 insertions(+), 3732 deletions(-)
 delete mode 100644 client/rsh/src/protocol.pb.cc
 delete mode 100644 client/rsh/src/protocol.pb.h

diff --git a/client/rsh/R/rsh.R b/client/rsh/R/rsh.R
index 893c63750..5240283d4 100644
--- a/client/rsh/R/rsh.R
+++ b/client/rsh/R/rsh.R
@@ -81,6 +81,10 @@ rsh_compile <- function(f, options) {
     options$inplace <- TRUE
   }
 
+  if(is.null(options$tier)) {
+    options$tier <- "optimized"
+  }
+
   invisible(.Call(C_compile, f, options))
 }
 
diff --git a/client/rsh/src/Makevars b/client/rsh/src/Makevars
index 29abc8bf8..bb091ecf8 100644
--- a/client/rsh/src/Makevars
+++ b/client/rsh/src/Makevars
@@ -3,19 +3,22 @@ LLVM_CONFIG := llvm-config-17
 LLVM_CPPFLAGS != $(LLVM_CONFIG) --cxxflags
 LLVM_LIBS != $(LLVM_CONFIG) --libs
 
+DEBUGFLAGS := -O0 -ggdb
+
 PB_CPPFLAGS != pkg-config --cflags protobuf
 PB_LIBS != pkg-config --libs protobuf
 GRPC_CPPFLAGS != pkg-config --cflags grpc++
 GRPC_LIBS != pkg-config --libs grpc++
 
 # Both C/C++ flags
-PKG_CPPFLAGS :=  -DR_NO_REMAP -DSTRICT_R_HEADERS -DUSE_RINTERNALS
+PKG_CPPFLAGS :=  -DR_NO_REMAP -DSTRICT_R_HEADERS -DUSE_RINTERNALS $(DEBUGFLAGS) 
 # C++ flags
 PKG_CXXFLAGS := $(LLVM_CPPFLAGS) $(PB_CPPFLAGS) $(GRPC_CPPFLAGS) -fexceptions -I../inst
 # C flags
 PKG_CFLAGS :=
 # Linker flags
-PKG_LIBS := $(LLVM_LIBS) $(PB_LIBS) $(GRPC_LIBS) -lzmq
+PKG_LIBS := $(LLVM_LIBS) $(PB_LIBS) $(GRPC_LIBS) -lzmq $(DEBUGFLAGS) 
+
 
 # Allow sources in subdirectories
 CPP_FILES = $(wildcard *.cpp **/*.cpp)
diff --git a/client/rsh/src/bc2c/runtime_impl.h b/client/rsh/src/bc2c/runtime_impl.h
index b8a559acd..dfe133b33 100644
--- a/client/rsh/src/bc2c/runtime_impl.h
+++ b/client/rsh/src/bc2c/runtime_impl.h
@@ -102,7 +102,7 @@ JIT_DEF SEXP Rsh_call_trampoline(SEXP call, SEXP op, SEXP args, SEXP rho) {
 
   SEXP cp = BCODE_CONSTS(body);
   if (XLENGTH(cp) != 6) {
-    Rf_error("Expected a constant pool with 6 elements");
+    Rf_error("Expected a constant pool with 6 elements, got %d", XLENGTH(cp));
   }
 
   SEXP c_cp = VECTOR_ELT(cp, LENGTH(cp) - 2);
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 774550a4e..0a4b72fbc 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -60,7 +60,7 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
 
   // We replace the body of a function with its compiled version so it would not make
   //sense to compute its hash again, except if its body has changed.
-  auto hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
+  uint64_t hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
   request.mutable_function()->set_hash(hash);
 
   grpc::ClientContext context;
@@ -92,7 +92,7 @@ SEXP Client::make_client(SEXP address, SEXP port, SEXP installed_packages) {
 
 
   SEXP ptr =  PROTECT(R_MakeExternalPtr(client, Rf_install("RSH_CLIENT"), R_NilValue));
-  R_RegisterCFinalizerEx(ptr, &Client::remove_client, TRUE);// TRUE because we want to shutdown the client when R quits
+  //R_RegisterCFinalizerEx(ptr, &Client::remove_client, TRUE);// TRUE because we want to shutdown the client when R quits
 
   UNPROTECT(1);
   return ptr;
diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index b89b30296..ae3dc09d7 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -1,6 +1,5 @@
 #include "compiler.hpp"
 #include "client.hpp"
-#include "protocol.pb.h"
 #include "rsh.hpp"
 #include "serialize.hpp"
 #include "util.hpp"
@@ -178,6 +177,7 @@ CompilerOptions CompilerOptions::from_list(SEXP listsxp) {
 
 
 std::string genSymbol(uint64_t hash, int index) {
+  
   return "gen_" + std::to_string(hash) + "_" + std::to_string(index);
 }
 
@@ -201,13 +201,14 @@ SEXP compile(SEXP closure, SEXP options) {
   auto compiled_fun = std::get<protocol::CompileResponse>(response);
 
   SEXP body = nullptr;
+  SEXP c_cp = nullptr;
   void * fun_ptr = nullptr;
   std::string name = genSymbol(compiled_fun.hash(), 0);
   // Native or bytecode?
   if(opts.tier == protocol::Tier::OPTIMIZED) {
     fun_ptr = insert_into_jit(name.c_str(), compiled_fun);
-    SEXP c_cp = PROTECT(create_constant_pool(fun_ptr, name.c_str(), compiled_fun));
-    body = PROTECT(create_wrapper_body(closure, c_cp));
+    c_cp = PROTECT(create_constant_pool(fun_ptr, name.c_str(), compiled_fun));
+    
   }
   else if(opts.tier == protocol::Tier::BASELINE) {
     body = PROTECT(rsh::deserialize(compiled_fun.code()));
@@ -218,6 +219,7 @@ SEXP compile(SEXP closure, SEXP options) {
 
   // Inplace or not (i.e. through through an explicit call to `compile` or through the R JIT)
   if (opts.inplace) {
+    body = PROTECT(create_wrapper_body(closure, c_cp));
     SET_BODY(closure, body);
     // FIXME: add logging primitives
     Rprintf("Compiled in place fun %s (fun=%p, body=%p) ; ",
@@ -231,8 +233,14 @@ SEXP compile(SEXP closure, SEXP options) {
     }
   } else {
     SEXP orig = closure;
-    closure = Rf_mkCLOSXP(FORMALS(closure), body, CLOENV(closure));
-    // FIXME: add logging primitives
+    closure = PROTECT(Rf_mkCLOSXP(FORMALS(closure), R_NilValue, CLOENV(closure)));
+    if(opts.tier == protocol::Tier::OPTIMIZED) {
+      // In that case, the body needs a reference to its body
+      body = PROTECT(create_wrapper_body(closure, c_cp));
+    }
+    SET_BODY(closure, body);
+    // FIXME: add logging primitive
+    UNPROTECT(1);
     Rprintf(
         "Replaced compiled fun %s -- %p (fun=%p, body=%p) ; ",
         opts.name.c_str(), orig, closure,
diff --git a/client/rsh/src/compiler.hpp b/client/rsh/src/compiler.hpp
index b679f4910..fbf3e73f8 100644
--- a/client/rsh/src/compiler.hpp
+++ b/client/rsh/src/compiler.hpp
@@ -9,10 +9,10 @@ namespace rsh {
 
 struct CompilerOptions {
   std::string name;
-  int bc_opt;
-  int cc_opt;
+  int bc_opt = 3;
+  int cc_opt = 3;
   bool inplace;
-  protocol::Tier tier;
+  protocol::Tier tier = protocol::Tier::OPTIMIZED;
 
   static CompilerOptions from_list(SEXP listsxp);
 };
diff --git a/client/rsh/src/protocol.pb.cc b/client/rsh/src/protocol.pb.cc
deleted file mode 100644
index a61c66dc7..000000000
--- a/client/rsh/src/protocol.pb.cc
+++ /dev/null
@@ -1,1771 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: protocol.proto
-
-#include "protocol.pb.h"
-
-#include <algorithm>
-
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/extension_set.h>
-#include <google/protobuf/wire_format_lite.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/reflection_ops.h>
-#include <google/protobuf/wire_format.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-
-PROTOBUF_PRAGMA_INIT_SEG
-
-namespace _pb = ::PROTOBUF_NAMESPACE_ID;
-namespace _pbi = _pb::internal;
-
-namespace rsh {
-namespace server {
-namespace protocol {
-PROTOBUF_CONSTEXPR Request::Request(
-    ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.payload_)*/{}
-  , /*decltype(_impl_._cached_size_)*/{}
-  , /*decltype(_impl_._oneof_case_)*/{}} {}
-struct RequestDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR RequestDefaultTypeInternal()
-      : _instance(::_pbi::ConstantInitialized{}) {}
-  ~RequestDefaultTypeInternal() {}
-  union {
-    Request _instance;
-  };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestDefaultTypeInternal _Request_default_instance_;
-PROTOBUF_CONSTEXPR HandshakeRequest::HandshakeRequest(
-    ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.packages_)*/{}
-  , /*decltype(_impl_.rsh_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.r_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.platform_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_._cached_size_)*/{}} {}
-struct HandshakeRequestDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR HandshakeRequestDefaultTypeInternal()
-      : _instance(::_pbi::ConstantInitialized{}) {}
-  ~HandshakeRequestDefaultTypeInternal() {}
-  union {
-    HandshakeRequest _instance;
-  };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_;
-PROTOBUF_CONSTEXPR CompileRequest::CompileRequest(
-    ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.closure_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.bc_optimization_)*/0u
-  , /*decltype(_impl_.cc_optimization_)*/0u
-  , /*decltype(_impl_._cached_size_)*/{}} {}
-struct CompileRequestDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR CompileRequestDefaultTypeInternal()
-      : _instance(::_pbi::ConstantInitialized{}) {}
-  ~CompileRequestDefaultTypeInternal() {}
-  union {
-    CompileRequest _instance;
-  };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompileRequestDefaultTypeInternal _CompileRequest_default_instance_;
-PROTOBUF_CONSTEXPR CompiledFunction::CompiledFunction(
-    ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.native_code_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_.constants_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
-  , /*decltype(_impl_._cached_size_)*/{}} {}
-struct CompiledFunctionDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR CompiledFunctionDefaultTypeInternal()
-      : _instance(::_pbi::ConstantInitialized{}) {}
-  ~CompiledFunctionDefaultTypeInternal() {}
-  union {
-    CompiledFunction _instance;
-  };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompiledFunctionDefaultTypeInternal _CompiledFunction_default_instance_;
-PROTOBUF_CONSTEXPR CompileResponse::CompileResponse(
-    ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.data_)*/{}
-  , /*decltype(_impl_._cached_size_)*/{}
-  , /*decltype(_impl_._oneof_case_)*/{}} {}
-struct CompileResponseDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR CompileResponseDefaultTypeInternal()
-      : _instance(::_pbi::ConstantInitialized{}) {}
-  ~CompileResponseDefaultTypeInternal() {}
-  union {
-    CompileResponse _instance;
-  };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CompileResponseDefaultTypeInternal _CompileResponse_default_instance_;
-}  // namespace protocol
-}  // namespace server
-}  // namespace rsh
-static ::_pb::Metadata file_level_metadata_protocol_2eproto[5];
-static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_protocol_2eproto = nullptr;
-static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_protocol_2eproto = nullptr;
-
-const uint32_t TableStruct_protocol_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _internal_metadata_),
-  ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _impl_._oneof_case_[0]),
-  ~0u,  // no _weak_field_map_
-  ~0u,  // no _inlined_string_donated_
-  ::_pbi::kInvalidFieldOffsetTag,
-  ::_pbi::kInvalidFieldOffsetTag,
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::Request, _impl_.payload_),
-  ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _internal_metadata_),
-  ~0u,  // no _extensions_
-  ~0u,  // no _oneof_case_
-  ~0u,  // no _weak_field_map_
-  ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.rsh_version_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.r_version_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.platform_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::HandshakeRequest, _impl_.packages_),
-  ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _internal_metadata_),
-  ~0u,  // no _extensions_
-  ~0u,  // no _oneof_case_
-  ~0u,  // no _weak_field_map_
-  ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.name_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.closure_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.bc_optimization_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileRequest, _impl_.cc_optimization_),
-  ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _internal_metadata_),
-  ~0u,  // no _extensions_
-  ~0u,  // no _oneof_case_
-  ~0u,  // no _weak_field_map_
-  ~0u,  // no _inlined_string_donated_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _impl_.name_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _impl_.native_code_),
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompiledFunction, _impl_.constants_),
-  ~0u,  // no _has_bits_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _internal_metadata_),
-  ~0u,  // no _extensions_
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _impl_._oneof_case_[0]),
-  ~0u,  // no _weak_field_map_
-  ~0u,  // no _inlined_string_donated_
-  ::_pbi::kInvalidFieldOffsetTag,
-  ::_pbi::kInvalidFieldOffsetTag,
-  PROTOBUF_FIELD_OFFSET(::rsh::server::protocol::CompileResponse, _impl_.data_),
-};
-static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, -1, -1, sizeof(::rsh::server::protocol::Request)},
-  { 9, -1, -1, sizeof(::rsh::server::protocol::HandshakeRequest)},
-  { 19, -1, -1, sizeof(::rsh::server::protocol::CompileRequest)},
-  { 29, -1, -1, sizeof(::rsh::server::protocol::CompiledFunction)},
-  { 38, -1, -1, sizeof(::rsh::server::protocol::CompileResponse)},
-};
-
-static const ::_pb::Message* const file_default_instances[] = {
-  &::rsh::server::protocol::_Request_default_instance_._instance,
-  &::rsh::server::protocol::_HandshakeRequest_default_instance_._instance,
-  &::rsh::server::protocol::_CompileRequest_default_instance_._instance,
-  &::rsh::server::protocol::_CompiledFunction_default_instance_._instance,
-  &::rsh::server::protocol::_CompileResponse_default_instance_._instance,
-};
-
-const char descriptor_table_protodef_protocol_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
-  "\n\016protocol.proto\022\023rsh.server.protocol\"\210\001"
-  "\n\007Request\022:\n\thandshake\030\001 \001(\0132%.rsh.serve"
-  "r.protocol.HandshakeRequestH\000\0226\n\007compile"
-  "\030\002 \001(\0132#.rsh.server.protocol.CompileRequ"
-  "estH\000B\t\n\007payload\"^\n\020HandshakeRequest\022\023\n\013"
-  "Rsh_version\030\001 \001(\t\022\021\n\tR_version\030\002 \001(\t\022\020\n\010"
-  "platform\030\003 \001(\t\022\020\n\010packages\030\004 \003(\t\"a\n\016Comp"
-  "ileRequest\022\014\n\004name\030\002 \001(\t\022\017\n\007closure\030\003 \001("
-  "\014\022\027\n\017bc_optimization\030\004 \001(\r\022\027\n\017cc_optimiz"
-  "ation\030\005 \001(\r\"H\n\020CompiledFunction\022\014\n\004name\030"
-  "\002 \001(\t\022\023\n\013native_code\030\003 \001(\014\022\021\n\tconstants\030"
-  "\004 \001(\014\"e\n\017CompileResponse\022\021\n\007failure\030\002 \001("
-  "\tH\000\0227\n\006result\030\003 \001(\0132%.rsh.server.protoco"
-  "l.CompiledFunctionH\000B\006\n\004dataB\036\n\032org.prlp"
-  "rg.server.protocolP\001b\006proto3"
-  ;
-static ::_pbi::once_flag descriptor_table_protocol_2eproto_once;
-const ::_pbi::DescriptorTable descriptor_table_protocol_2eproto = {
-    false, false, 588, descriptor_table_protodef_protocol_2eproto,
-    "protocol.proto",
-    &descriptor_table_protocol_2eproto_once, nullptr, 0, 5,
-    schemas, file_default_instances, TableStruct_protocol_2eproto::offsets,
-    file_level_metadata_protocol_2eproto, file_level_enum_descriptors_protocol_2eproto,
-    file_level_service_descriptors_protocol_2eproto,
-};
-PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_protocol_2eproto_getter() {
-  return &descriptor_table_protocol_2eproto;
-}
-
-// Force running AddDescriptors() at dynamic initialization time.
-PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_protocol_2eproto(&descriptor_table_protocol_2eproto);
-namespace rsh {
-namespace server {
-namespace protocol {
-
-// ===================================================================
-
-class Request::_Internal {
- public:
-  static const ::rsh::server::protocol::HandshakeRequest& handshake(const Request* msg);
-  static const ::rsh::server::protocol::CompileRequest& compile(const Request* msg);
-};
-
-const ::rsh::server::protocol::HandshakeRequest&
-Request::_Internal::handshake(const Request* msg) {
-  return *msg->_impl_.payload_.handshake_;
-}
-const ::rsh::server::protocol::CompileRequest&
-Request::_Internal::compile(const Request* msg) {
-  return *msg->_impl_.payload_.compile_;
-}
-void Request::set_allocated_handshake(::rsh::server::protocol::HandshakeRequest* handshake) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  clear_payload();
-  if (handshake) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(handshake);
-    if (message_arena != submessage_arena) {
-      handshake = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, handshake, submessage_arena);
-    }
-    set_has_handshake();
-    _impl_.payload_.handshake_ = handshake;
-  }
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.Request.handshake)
-}
-void Request::set_allocated_compile(::rsh::server::protocol::CompileRequest* compile) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  clear_payload();
-  if (compile) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compile);
-    if (message_arena != submessage_arena) {
-      compile = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, compile, submessage_arena);
-    }
-    set_has_compile();
-    _impl_.payload_.compile_ = compile;
-  }
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.Request.compile)
-}
-Request::Request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                         bool is_message_owned)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
-  SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.Request)
-}
-Request::Request(const Request& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message() {
-  Request* const _this = this; (void)_this;
-  new (&_impl_) Impl_{
-      decltype(_impl_.payload_){}
-    , /*decltype(_impl_._cached_size_)*/{}
-    , /*decltype(_impl_._oneof_case_)*/{}};
-
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  clear_has_payload();
-  switch (from.payload_case()) {
-    case kHandshake: {
-      _this->_internal_mutable_handshake()->::rsh::server::protocol::HandshakeRequest::MergeFrom(
-          from._internal_handshake());
-      break;
-    }
-    case kCompile: {
-      _this->_internal_mutable_compile()->::rsh::server::protocol::CompileRequest::MergeFrom(
-          from._internal_compile());
-      break;
-    }
-    case PAYLOAD_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.Request)
-}
-
-inline void Request::SharedCtor(
-    ::_pb::Arena* arena, bool is_message_owned) {
-  (void)arena;
-  (void)is_message_owned;
-  new (&_impl_) Impl_{
-      decltype(_impl_.payload_){}
-    , /*decltype(_impl_._cached_size_)*/{}
-    , /*decltype(_impl_._oneof_case_)*/{}
-  };
-  clear_has_payload();
-}
-
-Request::~Request() {
-  // @@protoc_insertion_point(destructor:rsh.server.protocol.Request)
-  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
-  (void)arena;
-    return;
-  }
-  SharedDtor();
-}
-
-inline void Request::SharedDtor() {
-  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  if (has_payload()) {
-    clear_payload();
-  }
-}
-
-void Request::SetCachedSize(int size) const {
-  _impl_._cached_size_.Set(size);
-}
-
-void Request::clear_payload() {
-// @@protoc_insertion_point(one_of_clear_start:rsh.server.protocol.Request)
-  switch (payload_case()) {
-    case kHandshake: {
-      if (GetArenaForAllocation() == nullptr) {
-        delete _impl_.payload_.handshake_;
-      }
-      break;
-    }
-    case kCompile: {
-      if (GetArenaForAllocation() == nullptr) {
-        delete _impl_.payload_.compile_;
-      }
-      break;
-    }
-    case PAYLOAD_NOT_SET: {
-      break;
-    }
-  }
-  _impl_._oneof_case_[0] = PAYLOAD_NOT_SET;
-}
-
-
-void Request::Clear() {
-// @@protoc_insertion_point(message_clear_start:rsh.server.protocol.Request)
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  clear_payload();
-  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* Request::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag;
-    ptr = ::_pbi::ReadTag(ptr, &tag);
-    switch (tag >> 3) {
-      // .rsh.server.protocol.HandshakeRequest handshake = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_handshake(), ptr);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      // .rsh.server.protocol.CompileRequest compile = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_compile(), ptr);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      default:
-        goto handle_unusual;
-    }  // switch
-  handle_unusual:
-    if ((tag == 0) || ((tag & 7) == 4)) {
-      CHK_(ptr);
-      ctx->SetLastTag(tag);
-      goto message_done;
-    }
-    ptr = UnknownFieldParse(
-        tag,
-        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-        ptr, ctx);
-    CHK_(ptr != nullptr);
-  }  // while
-message_done:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto message_done;
-#undef CHK_
-}
-
-uint8_t* Request::_InternalSerialize(
-    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.Request)
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // .rsh.server.protocol.HandshakeRequest handshake = 1;
-  if (_internal_has_handshake()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, _Internal::handshake(this),
-        _Internal::handshake(this).GetCachedSize(), target, stream);
-  }
-
-  // .rsh.server.protocol.CompileRequest compile = 2;
-  if (_internal_has_compile()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, _Internal::compile(this),
-        _Internal::compile(this).GetCachedSize(), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.Request)
-  return target;
-}
-
-size_t Request::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.Request)
-  size_t total_size = 0;
-
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  switch (payload_case()) {
-    // .rsh.server.protocol.HandshakeRequest handshake = 1;
-    case kHandshake: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *_impl_.payload_.handshake_);
-      break;
-    }
-    // .rsh.server.protocol.CompileRequest compile = 2;
-    case kCompile: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *_impl_.payload_.compile_);
-      break;
-    }
-    case PAYLOAD_NOT_SET: {
-      break;
-    }
-  }
-  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
-}
-
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Request::_class_data_ = {
-    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    Request::MergeImpl
-};
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Request::GetClassData() const { return &_class_data_; }
-
-
-void Request::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<Request*>(&to_msg);
-  auto& from = static_cast<const Request&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.Request)
-  GOOGLE_DCHECK_NE(&from, _this);
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  switch (from.payload_case()) {
-    case kHandshake: {
-      _this->_internal_mutable_handshake()->::rsh::server::protocol::HandshakeRequest::MergeFrom(
-          from._internal_handshake());
-      break;
-    }
-    case kCompile: {
-      _this->_internal_mutable_compile()->::rsh::server::protocol::CompileRequest::MergeFrom(
-          from._internal_compile());
-      break;
-    }
-    case PAYLOAD_NOT_SET: {
-      break;
-    }
-  }
-  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-}
-
-void Request::CopyFrom(const Request& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:rsh.server.protocol.Request)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool Request::IsInitialized() const {
-  return true;
-}
-
-void Request::InternalSwap(Request* other) {
-  using std::swap;
-  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  swap(_impl_.payload_, other->_impl_.payload_);
-  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata Request::GetMetadata() const {
-  return ::_pbi::AssignDescriptors(
-      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
-      file_level_metadata_protocol_2eproto[0]);
-}
-
-// ===================================================================
-
-class HandshakeRequest::_Internal {
- public:
-};
-
-HandshakeRequest::HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                         bool is_message_owned)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
-  SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.HandshakeRequest)
-}
-HandshakeRequest::HandshakeRequest(const HandshakeRequest& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message() {
-  HandshakeRequest* const _this = this; (void)_this;
-  new (&_impl_) Impl_{
-      decltype(_impl_.packages_){from._impl_.packages_}
-    , decltype(_impl_.rsh_version_){}
-    , decltype(_impl_.r_version_){}
-    , decltype(_impl_.platform_){}
-    , /*decltype(_impl_._cached_size_)*/{}};
-
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.rsh_version_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.rsh_version_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_rsh_version().empty()) {
-    _this->_impl_.rsh_version_.Set(from._internal_rsh_version(), 
-      _this->GetArenaForAllocation());
-  }
-  _impl_.r_version_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.r_version_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_r_version().empty()) {
-    _this->_impl_.r_version_.Set(from._internal_r_version(), 
-      _this->GetArenaForAllocation());
-  }
-  _impl_.platform_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.platform_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_platform().empty()) {
-    _this->_impl_.platform_.Set(from._internal_platform(), 
-      _this->GetArenaForAllocation());
-  }
-  // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.HandshakeRequest)
-}
-
-inline void HandshakeRequest::SharedCtor(
-    ::_pb::Arena* arena, bool is_message_owned) {
-  (void)arena;
-  (void)is_message_owned;
-  new (&_impl_) Impl_{
-      decltype(_impl_.packages_){arena}
-    , decltype(_impl_.rsh_version_){}
-    , decltype(_impl_.r_version_){}
-    , decltype(_impl_.platform_){}
-    , /*decltype(_impl_._cached_size_)*/{}
-  };
-  _impl_.rsh_version_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.rsh_version_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.r_version_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.r_version_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.platform_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.platform_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-}
-
-HandshakeRequest::~HandshakeRequest() {
-  // @@protoc_insertion_point(destructor:rsh.server.protocol.HandshakeRequest)
-  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
-  (void)arena;
-    return;
-  }
-  SharedDtor();
-}
-
-inline void HandshakeRequest::SharedDtor() {
-  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.packages_.~RepeatedPtrField();
-  _impl_.rsh_version_.Destroy();
-  _impl_.r_version_.Destroy();
-  _impl_.platform_.Destroy();
-}
-
-void HandshakeRequest::SetCachedSize(int size) const {
-  _impl_._cached_size_.Set(size);
-}
-
-void HandshakeRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:rsh.server.protocol.HandshakeRequest)
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  _impl_.packages_.Clear();
-  _impl_.rsh_version_.ClearToEmpty();
-  _impl_.r_version_.ClearToEmpty();
-  _impl_.platform_.ClearToEmpty();
-  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* HandshakeRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag;
-    ptr = ::_pbi::ReadTag(ptr, &tag);
-    switch (tag >> 3) {
-      // string Rsh_version = 1;
-      case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
-          auto str = _internal_mutable_rsh_version();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.Rsh_version"));
-        } else
-          goto handle_unusual;
-        continue;
-      // string R_version = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
-          auto str = _internal_mutable_r_version();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.R_version"));
-        } else
-          goto handle_unusual;
-        continue;
-      // string platform = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
-          auto str = _internal_mutable_platform();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.platform"));
-        } else
-          goto handle_unusual;
-        continue;
-      // repeated string packages = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
-          ptr -= 1;
-          do {
-            ptr += 1;
-            auto str = _internal_add_packages();
-            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-            CHK_(ptr);
-            CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.HandshakeRequest.packages"));
-            if (!ctx->DataAvailable(ptr)) break;
-          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
-        } else
-          goto handle_unusual;
-        continue;
-      default:
-        goto handle_unusual;
-    }  // switch
-  handle_unusual:
-    if ((tag == 0) || ((tag & 7) == 4)) {
-      CHK_(ptr);
-      ctx->SetLastTag(tag);
-      goto message_done;
-    }
-    ptr = UnknownFieldParse(
-        tag,
-        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-        ptr, ctx);
-    CHK_(ptr != nullptr);
-  }  // while
-message_done:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto message_done;
-#undef CHK_
-}
-
-uint8_t* HandshakeRequest::_InternalSerialize(
-    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.HandshakeRequest)
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string Rsh_version = 1;
-  if (!this->_internal_rsh_version().empty()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_rsh_version().data(), static_cast<int>(this->_internal_rsh_version().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.HandshakeRequest.Rsh_version");
-    target = stream->WriteStringMaybeAliased(
-        1, this->_internal_rsh_version(), target);
-  }
-
-  // string R_version = 2;
-  if (!this->_internal_r_version().empty()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_r_version().data(), static_cast<int>(this->_internal_r_version().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.HandshakeRequest.R_version");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_r_version(), target);
-  }
-
-  // string platform = 3;
-  if (!this->_internal_platform().empty()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_platform().data(), static_cast<int>(this->_internal_platform().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.HandshakeRequest.platform");
-    target = stream->WriteStringMaybeAliased(
-        3, this->_internal_platform(), target);
-  }
-
-  // repeated string packages = 4;
-  for (int i = 0, n = this->_internal_packages_size(); i < n; i++) {
-    const auto& s = this->_internal_packages(i);
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      s.data(), static_cast<int>(s.length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.HandshakeRequest.packages");
-    target = stream->WriteString(4, s, target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.HandshakeRequest)
-  return target;
-}
-
-size_t HandshakeRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.HandshakeRequest)
-  size_t total_size = 0;
-
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // repeated string packages = 4;
-  total_size += 1 *
-      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.packages_.size());
-  for (int i = 0, n = _impl_.packages_.size(); i < n; i++) {
-    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-      _impl_.packages_.Get(i));
-  }
-
-  // string Rsh_version = 1;
-  if (!this->_internal_rsh_version().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_rsh_version());
-  }
-
-  // string R_version = 2;
-  if (!this->_internal_r_version().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_r_version());
-  }
-
-  // string platform = 3;
-  if (!this->_internal_platform().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_platform());
-  }
-
-  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
-}
-
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeRequest::_class_data_ = {
-    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    HandshakeRequest::MergeImpl
-};
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeRequest::GetClassData() const { return &_class_data_; }
-
-
-void HandshakeRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<HandshakeRequest*>(&to_msg);
-  auto& from = static_cast<const HandshakeRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.HandshakeRequest)
-  GOOGLE_DCHECK_NE(&from, _this);
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  _this->_impl_.packages_.MergeFrom(from._impl_.packages_);
-  if (!from._internal_rsh_version().empty()) {
-    _this->_internal_set_rsh_version(from._internal_rsh_version());
-  }
-  if (!from._internal_r_version().empty()) {
-    _this->_internal_set_r_version(from._internal_r_version());
-  }
-  if (!from._internal_platform().empty()) {
-    _this->_internal_set_platform(from._internal_platform());
-  }
-  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-}
-
-void HandshakeRequest::CopyFrom(const HandshakeRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:rsh.server.protocol.HandshakeRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool HandshakeRequest::IsInitialized() const {
-  return true;
-}
-
-void HandshakeRequest::InternalSwap(HandshakeRequest* other) {
-  using std::swap;
-  auto* lhs_arena = GetArenaForAllocation();
-  auto* rhs_arena = other->GetArenaForAllocation();
-  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  _impl_.packages_.InternalSwap(&other->_impl_.packages_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.rsh_version_, lhs_arena,
-      &other->_impl_.rsh_version_, rhs_arena
-  );
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.r_version_, lhs_arena,
-      &other->_impl_.r_version_, rhs_arena
-  );
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.platform_, lhs_arena,
-      &other->_impl_.platform_, rhs_arena
-  );
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata HandshakeRequest::GetMetadata() const {
-  return ::_pbi::AssignDescriptors(
-      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
-      file_level_metadata_protocol_2eproto[1]);
-}
-
-// ===================================================================
-
-class CompileRequest::_Internal {
- public:
-};
-
-CompileRequest::CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                         bool is_message_owned)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
-  SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.CompileRequest)
-}
-CompileRequest::CompileRequest(const CompileRequest& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message() {
-  CompileRequest* const _this = this; (void)_this;
-  new (&_impl_) Impl_{
-      decltype(_impl_.name_){}
-    , decltype(_impl_.closure_){}
-    , decltype(_impl_.bc_optimization_){}
-    , decltype(_impl_.cc_optimization_){}
-    , /*decltype(_impl_._cached_size_)*/{}};
-
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.name_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.name_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_name().empty()) {
-    _this->_impl_.name_.Set(from._internal_name(), 
-      _this->GetArenaForAllocation());
-  }
-  _impl_.closure_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.closure_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_closure().empty()) {
-    _this->_impl_.closure_.Set(from._internal_closure(), 
-      _this->GetArenaForAllocation());
-  }
-  ::memcpy(&_impl_.bc_optimization_, &from._impl_.bc_optimization_,
-    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cc_optimization_) -
-    reinterpret_cast<char*>(&_impl_.bc_optimization_)) + sizeof(_impl_.cc_optimization_));
-  // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.CompileRequest)
-}
-
-inline void CompileRequest::SharedCtor(
-    ::_pb::Arena* arena, bool is_message_owned) {
-  (void)arena;
-  (void)is_message_owned;
-  new (&_impl_) Impl_{
-      decltype(_impl_.name_){}
-    , decltype(_impl_.closure_){}
-    , decltype(_impl_.bc_optimization_){0u}
-    , decltype(_impl_.cc_optimization_){0u}
-    , /*decltype(_impl_._cached_size_)*/{}
-  };
-  _impl_.name_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.name_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.closure_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.closure_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-}
-
-CompileRequest::~CompileRequest() {
-  // @@protoc_insertion_point(destructor:rsh.server.protocol.CompileRequest)
-  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
-  (void)arena;
-    return;
-  }
-  SharedDtor();
-}
-
-inline void CompileRequest::SharedDtor() {
-  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.name_.Destroy();
-  _impl_.closure_.Destroy();
-}
-
-void CompileRequest::SetCachedSize(int size) const {
-  _impl_._cached_size_.Set(size);
-}
-
-void CompileRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:rsh.server.protocol.CompileRequest)
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  _impl_.name_.ClearToEmpty();
-  _impl_.closure_.ClearToEmpty();
-  ::memset(&_impl_.bc_optimization_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&_impl_.cc_optimization_) -
-      reinterpret_cast<char*>(&_impl_.bc_optimization_)) + sizeof(_impl_.cc_optimization_));
-  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* CompileRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag;
-    ptr = ::_pbi::ReadTag(ptr, &tag);
-    switch (tag >> 3) {
-      // string name = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
-          auto str = _internal_mutable_name();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.CompileRequest.name"));
-        } else
-          goto handle_unusual;
-        continue;
-      // bytes closure = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
-          auto str = _internal_mutable_closure();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      // uint32 bc_optimization = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
-          _impl_.bc_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      // uint32 cc_optimization = 5;
-      case 5:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
-          _impl_.cc_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      default:
-        goto handle_unusual;
-    }  // switch
-  handle_unusual:
-    if ((tag == 0) || ((tag & 7) == 4)) {
-      CHK_(ptr);
-      ctx->SetLastTag(tag);
-      goto message_done;
-    }
-    ptr = UnknownFieldParse(
-        tag,
-        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-        ptr, ctx);
-    CHK_(ptr != nullptr);
-  }  // while
-message_done:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto message_done;
-#undef CHK_
-}
-
-uint8_t* CompileRequest::_InternalSerialize(
-    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.CompileRequest)
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string name = 2;
-  if (!this->_internal_name().empty()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.CompileRequest.name");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_name(), target);
-  }
-
-  // bytes closure = 3;
-  if (!this->_internal_closure().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        3, this->_internal_closure(), target);
-  }
-
-  // uint32 bc_optimization = 4;
-  if (this->_internal_bc_optimization() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bc_optimization(), target);
-  }
-
-  // uint32 cc_optimization = 5;
-  if (this->_internal_cc_optimization() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_cc_optimization(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.CompileRequest)
-  return target;
-}
-
-size_t CompileRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.CompileRequest)
-  size_t total_size = 0;
-
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // string name = 2;
-  if (!this->_internal_name().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // bytes closure = 3;
-  if (!this->_internal_closure().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_closure());
-  }
-
-  // uint32 bc_optimization = 4;
-  if (this->_internal_bc_optimization() != 0) {
-    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bc_optimization());
-  }
-
-  // uint32 cc_optimization = 5;
-  if (this->_internal_cc_optimization() != 0) {
-    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cc_optimization());
-  }
-
-  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
-}
-
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompileRequest::_class_data_ = {
-    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    CompileRequest::MergeImpl
-};
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileRequest::GetClassData() const { return &_class_data_; }
-
-
-void CompileRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<CompileRequest*>(&to_msg);
-  auto& from = static_cast<const CompileRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompileRequest)
-  GOOGLE_DCHECK_NE(&from, _this);
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (!from._internal_name().empty()) {
-    _this->_internal_set_name(from._internal_name());
-  }
-  if (!from._internal_closure().empty()) {
-    _this->_internal_set_closure(from._internal_closure());
-  }
-  if (from._internal_bc_optimization() != 0) {
-    _this->_internal_set_bc_optimization(from._internal_bc_optimization());
-  }
-  if (from._internal_cc_optimization() != 0) {
-    _this->_internal_set_cc_optimization(from._internal_cc_optimization());
-  }
-  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-}
-
-void CompileRequest::CopyFrom(const CompileRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:rsh.server.protocol.CompileRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CompileRequest::IsInitialized() const {
-  return true;
-}
-
-void CompileRequest::InternalSwap(CompileRequest* other) {
-  using std::swap;
-  auto* lhs_arena = GetArenaForAllocation();
-  auto* rhs_arena = other->GetArenaForAllocation();
-  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.name_, lhs_arena,
-      &other->_impl_.name_, rhs_arena
-  );
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.closure_, lhs_arena,
-      &other->_impl_.closure_, rhs_arena
-  );
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(CompileRequest, _impl_.cc_optimization_)
-      + sizeof(CompileRequest::_impl_.cc_optimization_)
-      - PROTOBUF_FIELD_OFFSET(CompileRequest, _impl_.bc_optimization_)>(
-          reinterpret_cast<char*>(&_impl_.bc_optimization_),
-          reinterpret_cast<char*>(&other->_impl_.bc_optimization_));
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata CompileRequest::GetMetadata() const {
-  return ::_pbi::AssignDescriptors(
-      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
-      file_level_metadata_protocol_2eproto[2]);
-}
-
-// ===================================================================
-
-class CompiledFunction::_Internal {
- public:
-};
-
-CompiledFunction::CompiledFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                         bool is_message_owned)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
-  SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.CompiledFunction)
-}
-CompiledFunction::CompiledFunction(const CompiledFunction& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message() {
-  CompiledFunction* const _this = this; (void)_this;
-  new (&_impl_) Impl_{
-      decltype(_impl_.name_){}
-    , decltype(_impl_.native_code_){}
-    , decltype(_impl_.constants_){}
-    , /*decltype(_impl_._cached_size_)*/{}};
-
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  _impl_.name_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.name_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_name().empty()) {
-    _this->_impl_.name_.Set(from._internal_name(), 
-      _this->GetArenaForAllocation());
-  }
-  _impl_.native_code_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.native_code_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_native_code().empty()) {
-    _this->_impl_.native_code_.Set(from._internal_native_code(), 
-      _this->GetArenaForAllocation());
-  }
-  _impl_.constants_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.constants_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (!from._internal_constants().empty()) {
-    _this->_impl_.constants_.Set(from._internal_constants(), 
-      _this->GetArenaForAllocation());
-  }
-  // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.CompiledFunction)
-}
-
-inline void CompiledFunction::SharedCtor(
-    ::_pb::Arena* arena, bool is_message_owned) {
-  (void)arena;
-  (void)is_message_owned;
-  new (&_impl_) Impl_{
-      decltype(_impl_.name_){}
-    , decltype(_impl_.native_code_){}
-    , decltype(_impl_.constants_){}
-    , /*decltype(_impl_._cached_size_)*/{}
-  };
-  _impl_.name_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.name_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.native_code_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.native_code_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  _impl_.constants_.InitDefault();
-  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-    _impl_.constants_.Set("", GetArenaForAllocation());
-  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-}
-
-CompiledFunction::~CompiledFunction() {
-  // @@protoc_insertion_point(destructor:rsh.server.protocol.CompiledFunction)
-  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
-  (void)arena;
-    return;
-  }
-  SharedDtor();
-}
-
-inline void CompiledFunction::SharedDtor() {
-  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  _impl_.name_.Destroy();
-  _impl_.native_code_.Destroy();
-  _impl_.constants_.Destroy();
-}
-
-void CompiledFunction::SetCachedSize(int size) const {
-  _impl_._cached_size_.Set(size);
-}
-
-void CompiledFunction::Clear() {
-// @@protoc_insertion_point(message_clear_start:rsh.server.protocol.CompiledFunction)
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  _impl_.name_.ClearToEmpty();
-  _impl_.native_code_.ClearToEmpty();
-  _impl_.constants_.ClearToEmpty();
-  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* CompiledFunction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag;
-    ptr = ::_pbi::ReadTag(ptr, &tag);
-    switch (tag >> 3) {
-      // string name = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
-          auto str = _internal_mutable_name();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.CompiledFunction.name"));
-        } else
-          goto handle_unusual;
-        continue;
-      // bytes native_code = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
-          auto str = _internal_mutable_native_code();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      // bytes constants = 4;
-      case 4:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
-          auto str = _internal_mutable_constants();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      default:
-        goto handle_unusual;
-    }  // switch
-  handle_unusual:
-    if ((tag == 0) || ((tag & 7) == 4)) {
-      CHK_(ptr);
-      ctx->SetLastTag(tag);
-      goto message_done;
-    }
-    ptr = UnknownFieldParse(
-        tag,
-        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-        ptr, ctx);
-    CHK_(ptr != nullptr);
-  }  // while
-message_done:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto message_done;
-#undef CHK_
-}
-
-uint8_t* CompiledFunction::_InternalSerialize(
-    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.CompiledFunction)
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string name = 2;
-  if (!this->_internal_name().empty()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.CompiledFunction.name");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_name(), target);
-  }
-
-  // bytes native_code = 3;
-  if (!this->_internal_native_code().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        3, this->_internal_native_code(), target);
-  }
-
-  // bytes constants = 4;
-  if (!this->_internal_constants().empty()) {
-    target = stream->WriteBytesMaybeAliased(
-        4, this->_internal_constants(), target);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.CompiledFunction)
-  return target;
-}
-
-size_t CompiledFunction::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.CompiledFunction)
-  size_t total_size = 0;
-
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  // string name = 2;
-  if (!this->_internal_name().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->_internal_name());
-  }
-
-  // bytes native_code = 3;
-  if (!this->_internal_native_code().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_native_code());
-  }
-
-  // bytes constants = 4;
-  if (!this->_internal_constants().empty()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
-        this->_internal_constants());
-  }
-
-  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
-}
-
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompiledFunction::_class_data_ = {
-    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    CompiledFunction::MergeImpl
-};
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompiledFunction::GetClassData() const { return &_class_data_; }
-
-
-void CompiledFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<CompiledFunction*>(&to_msg);
-  auto& from = static_cast<const CompiledFunction&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompiledFunction)
-  GOOGLE_DCHECK_NE(&from, _this);
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  if (!from._internal_name().empty()) {
-    _this->_internal_set_name(from._internal_name());
-  }
-  if (!from._internal_native_code().empty()) {
-    _this->_internal_set_native_code(from._internal_native_code());
-  }
-  if (!from._internal_constants().empty()) {
-    _this->_internal_set_constants(from._internal_constants());
-  }
-  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-}
-
-void CompiledFunction::CopyFrom(const CompiledFunction& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:rsh.server.protocol.CompiledFunction)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CompiledFunction::IsInitialized() const {
-  return true;
-}
-
-void CompiledFunction::InternalSwap(CompiledFunction* other) {
-  using std::swap;
-  auto* lhs_arena = GetArenaForAllocation();
-  auto* rhs_arena = other->GetArenaForAllocation();
-  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.name_, lhs_arena,
-      &other->_impl_.name_, rhs_arena
-  );
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.native_code_, lhs_arena,
-      &other->_impl_.native_code_, rhs_arena
-  );
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
-      &_impl_.constants_, lhs_arena,
-      &other->_impl_.constants_, rhs_arena
-  );
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata CompiledFunction::GetMetadata() const {
-  return ::_pbi::AssignDescriptors(
-      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
-      file_level_metadata_protocol_2eproto[3]);
-}
-
-// ===================================================================
-
-class CompileResponse::_Internal {
- public:
-  static const ::rsh::server::protocol::CompiledFunction& result(const CompileResponse* msg);
-};
-
-const ::rsh::server::protocol::CompiledFunction&
-CompileResponse::_Internal::result(const CompileResponse* msg) {
-  return *msg->_impl_.data_.result_;
-}
-void CompileResponse::set_allocated_result(::rsh::server::protocol::CompiledFunction* result) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  clear_data();
-  if (result) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(result);
-    if (message_arena != submessage_arena) {
-      result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, result, submessage_arena);
-    }
-    set_has_result();
-    _impl_.data_.result_ = result;
-  }
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileResponse.result)
-}
-CompileResponse::CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                         bool is_message_owned)
-  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
-  SharedCtor(arena, is_message_owned);
-  // @@protoc_insertion_point(arena_constructor:rsh.server.protocol.CompileResponse)
-}
-CompileResponse::CompileResponse(const CompileResponse& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message() {
-  CompileResponse* const _this = this; (void)_this;
-  new (&_impl_) Impl_{
-      decltype(_impl_.data_){}
-    , /*decltype(_impl_._cached_size_)*/{}
-    , /*decltype(_impl_._oneof_case_)*/{}};
-
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-  clear_has_data();
-  switch (from.data_case()) {
-    case kFailure: {
-      _this->_internal_set_failure(from._internal_failure());
-      break;
-    }
-    case kResult: {
-      _this->_internal_mutable_result()->::rsh::server::protocol::CompiledFunction::MergeFrom(
-          from._internal_result());
-      break;
-    }
-    case DATA_NOT_SET: {
-      break;
-    }
-  }
-  // @@protoc_insertion_point(copy_constructor:rsh.server.protocol.CompileResponse)
-}
-
-inline void CompileResponse::SharedCtor(
-    ::_pb::Arena* arena, bool is_message_owned) {
-  (void)arena;
-  (void)is_message_owned;
-  new (&_impl_) Impl_{
-      decltype(_impl_.data_){}
-    , /*decltype(_impl_._cached_size_)*/{}
-    , /*decltype(_impl_._oneof_case_)*/{}
-  };
-  clear_has_data();
-}
-
-CompileResponse::~CompileResponse() {
-  // @@protoc_insertion_point(destructor:rsh.server.protocol.CompileResponse)
-  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
-  (void)arena;
-    return;
-  }
-  SharedDtor();
-}
-
-inline void CompileResponse::SharedDtor() {
-  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
-  if (has_data()) {
-    clear_data();
-  }
-}
-
-void CompileResponse::SetCachedSize(int size) const {
-  _impl_._cached_size_.Set(size);
-}
-
-void CompileResponse::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:rsh.server.protocol.CompileResponse)
-  switch (data_case()) {
-    case kFailure: {
-      _impl_.data_.failure_.Destroy();
-      break;
-    }
-    case kResult: {
-      if (GetArenaForAllocation() == nullptr) {
-        delete _impl_.data_.result_;
-      }
-      break;
-    }
-    case DATA_NOT_SET: {
-      break;
-    }
-  }
-  _impl_._oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void CompileResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:rsh.server.protocol.CompileResponse)
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  clear_data();
-  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* CompileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
-#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag;
-    ptr = ::_pbi::ReadTag(ptr, &tag);
-    switch (tag >> 3) {
-      // string failure = 2;
-      case 2:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
-          auto str = _internal_mutable_failure();
-          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
-          CHK_(ptr);
-          CHK_(::_pbi::VerifyUTF8(str, "rsh.server.protocol.CompileResponse.failure"));
-        } else
-          goto handle_unusual;
-        continue;
-      // .rsh.server.protocol.CompiledFunction result = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
-          ptr = ctx->ParseMessage(_internal_mutable_result(), ptr);
-          CHK_(ptr);
-        } else
-          goto handle_unusual;
-        continue;
-      default:
-        goto handle_unusual;
-    }  // switch
-  handle_unusual:
-    if ((tag == 0) || ((tag & 7) == 4)) {
-      CHK_(ptr);
-      ctx->SetLastTag(tag);
-      goto message_done;
-    }
-    ptr = UnknownFieldParse(
-        tag,
-        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
-        ptr, ctx);
-    CHK_(ptr != nullptr);
-  }  // while
-message_done:
-  return ptr;
-failure:
-  ptr = nullptr;
-  goto message_done;
-#undef CHK_
-}
-
-uint8_t* CompileResponse::_InternalSerialize(
-    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:rsh.server.protocol.CompileResponse)
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  // string failure = 2;
-  if (_internal_has_failure()) {
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->_internal_failure().data(), static_cast<int>(this->_internal_failure().length()),
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "rsh.server.protocol.CompileResponse.failure");
-    target = stream->WriteStringMaybeAliased(
-        2, this->_internal_failure(), target);
-  }
-
-  // .rsh.server.protocol.CompiledFunction result = 3;
-  if (_internal_has_result()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, _Internal::result(this),
-        _Internal::result(this).GetCachedSize(), target, stream);
-  }
-
-  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
-    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:rsh.server.protocol.CompileResponse)
-  return target;
-}
-
-size_t CompileResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:rsh.server.protocol.CompileResponse)
-  size_t total_size = 0;
-
-  uint32_t cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  switch (data_case()) {
-    // string failure = 2;
-    case kFailure: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-          this->_internal_failure());
-      break;
-    }
-    // .rsh.server.protocol.CompiledFunction result = 3;
-    case kResult: {
-      total_size += 1 +
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-          *_impl_.data_.result_);
-      break;
-    }
-    case DATA_NOT_SET: {
-      break;
-    }
-  }
-  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
-}
-
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CompileResponse::_class_data_ = {
-    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    CompileResponse::MergeImpl
-};
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CompileResponse::GetClassData() const { return &_class_data_; }
-
-
-void CompileResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<CompileResponse*>(&to_msg);
-  auto& from = static_cast<const CompileResponse&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:rsh.server.protocol.CompileResponse)
-  GOOGLE_DCHECK_NE(&from, _this);
-  uint32_t cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  switch (from.data_case()) {
-    case kFailure: {
-      _this->_internal_set_failure(from._internal_failure());
-      break;
-    }
-    case kResult: {
-      _this->_internal_mutable_result()->::rsh::server::protocol::CompiledFunction::MergeFrom(
-          from._internal_result());
-      break;
-    }
-    case DATA_NOT_SET: {
-      break;
-    }
-  }
-  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-}
-
-void CompileResponse::CopyFrom(const CompileResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:rsh.server.protocol.CompileResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CompileResponse::IsInitialized() const {
-  return true;
-}
-
-void CompileResponse::InternalSwap(CompileResponse* other) {
-  using std::swap;
-  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  swap(_impl_.data_, other->_impl_.data_);
-  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata CompileResponse::GetMetadata() const {
-  return ::_pbi::AssignDescriptors(
-      &descriptor_table_protocol_2eproto_getter, &descriptor_table_protocol_2eproto_once,
-      file_level_metadata_protocol_2eproto[4]);
-}
-
-// @@protoc_insertion_point(namespace_scope)
-}  // namespace protocol
-}  // namespace server
-}  // namespace rsh
-PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::Request*
-Arena::CreateMaybeMessage< ::rsh::server::protocol::Request >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::rsh::server::protocol::Request >(arena);
-}
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::HandshakeRequest*
-Arena::CreateMaybeMessage< ::rsh::server::protocol::HandshakeRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::rsh::server::protocol::HandshakeRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompileRequest*
-Arena::CreateMaybeMessage< ::rsh::server::protocol::CompileRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::rsh::server::protocol::CompileRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompiledFunction*
-Arena::CreateMaybeMessage< ::rsh::server::protocol::CompiledFunction >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::rsh::server::protocol::CompiledFunction >(arena);
-}
-template<> PROTOBUF_NOINLINE ::rsh::server::protocol::CompileResponse*
-Arena::CreateMaybeMessage< ::rsh::server::protocol::CompileResponse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::rsh::server::protocol::CompileResponse >(arena);
-}
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-#include <google/protobuf/port_undef.inc>
diff --git a/client/rsh/src/protocol.pb.h b/client/rsh/src/protocol.pb.h
deleted file mode 100644
index 4c0c20f57..000000000
--- a/client/rsh/src/protocol.pb.h
+++ /dev/null
@@ -1,1938 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: protocol.proto
-
-#ifndef GOOGLE_PROTOBUF_INCLUDED_protocol_2eproto
-#define GOOGLE_PROTOBUF_INCLUDED_protocol_2eproto
-
-#include <limits>
-#include <string>
-
-#include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3021000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please update
-#error your headers.
-#endif
-#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/port_undef.inc>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/metadata_lite.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/message.h>
-#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
-#include <google/protobuf/unknown_field_set.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-#define PROTOBUF_INTERNAL_EXPORT_protocol_2eproto
-PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
-}  // namespace internal
-PROTOBUF_NAMESPACE_CLOSE
-
-// Internal implementation detail -- do not use these members.
-struct TableStruct_protocol_2eproto {
-  static const uint32_t offsets[];
-};
-extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protocol_2eproto;
-namespace rsh {
-namespace server {
-namespace protocol {
-class CompileRequest;
-struct CompileRequestDefaultTypeInternal;
-extern CompileRequestDefaultTypeInternal _CompileRequest_default_instance_;
-class CompileResponse;
-struct CompileResponseDefaultTypeInternal;
-extern CompileResponseDefaultTypeInternal _CompileResponse_default_instance_;
-class CompiledFunction;
-struct CompiledFunctionDefaultTypeInternal;
-extern CompiledFunctionDefaultTypeInternal _CompiledFunction_default_instance_;
-class HandshakeRequest;
-struct HandshakeRequestDefaultTypeInternal;
-extern HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_;
-class Request;
-struct RequestDefaultTypeInternal;
-extern RequestDefaultTypeInternal _Request_default_instance_;
-}  // namespace protocol
-}  // namespace server
-}  // namespace rsh
-PROTOBUF_NAMESPACE_OPEN
-template<> ::rsh::server::protocol::CompileRequest* Arena::CreateMaybeMessage<::rsh::server::protocol::CompileRequest>(Arena*);
-template<> ::rsh::server::protocol::CompileResponse* Arena::CreateMaybeMessage<::rsh::server::protocol::CompileResponse>(Arena*);
-template<> ::rsh::server::protocol::CompiledFunction* Arena::CreateMaybeMessage<::rsh::server::protocol::CompiledFunction>(Arena*);
-template<> ::rsh::server::protocol::HandshakeRequest* Arena::CreateMaybeMessage<::rsh::server::protocol::HandshakeRequest>(Arena*);
-template<> ::rsh::server::protocol::Request* Arena::CreateMaybeMessage<::rsh::server::protocol::Request>(Arena*);
-PROTOBUF_NAMESPACE_CLOSE
-namespace rsh {
-namespace server {
-namespace protocol {
-
-// ===================================================================
-
-class Request final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.Request) */ {
- public:
-  inline Request() : Request(nullptr) {}
-  ~Request() override;
-  explicit PROTOBUF_CONSTEXPR Request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Request(const Request& from);
-  Request(Request&& from) noexcept
-    : Request() {
-    *this = ::std::move(from);
-  }
-
-  inline Request& operator=(const Request& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Request& operator=(Request&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Request& default_instance() {
-    return *internal_default_instance();
-  }
-  enum PayloadCase {
-    kHandshake = 1,
-    kCompile = 2,
-    PAYLOAD_NOT_SET = 0,
-  };
-
-  static inline const Request* internal_default_instance() {
-    return reinterpret_cast<const Request*>(
-               &_Request_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Request& a, Request& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Request* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Request* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Request>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Request& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Request& from) {
-    Request::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Request* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "rsh.server.protocol.Request";
-  }
-  protected:
-  explicit Request(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kHandshakeFieldNumber = 1,
-    kCompileFieldNumber = 2,
-  };
-  // .rsh.server.protocol.HandshakeRequest handshake = 1;
-  bool has_handshake() const;
-  private:
-  bool _internal_has_handshake() const;
-  public:
-  void clear_handshake();
-  const ::rsh::server::protocol::HandshakeRequest& handshake() const;
-  PROTOBUF_NODISCARD ::rsh::server::protocol::HandshakeRequest* release_handshake();
-  ::rsh::server::protocol::HandshakeRequest* mutable_handshake();
-  void set_allocated_handshake(::rsh::server::protocol::HandshakeRequest* handshake);
-  private:
-  const ::rsh::server::protocol::HandshakeRequest& _internal_handshake() const;
-  ::rsh::server::protocol::HandshakeRequest* _internal_mutable_handshake();
-  public:
-  void unsafe_arena_set_allocated_handshake(
-      ::rsh::server::protocol::HandshakeRequest* handshake);
-  ::rsh::server::protocol::HandshakeRequest* unsafe_arena_release_handshake();
-
-  // .rsh.server.protocol.CompileRequest compile = 2;
-  bool has_compile() const;
-  private:
-  bool _internal_has_compile() const;
-  public:
-  void clear_compile();
-  const ::rsh::server::protocol::CompileRequest& compile() const;
-  PROTOBUF_NODISCARD ::rsh::server::protocol::CompileRequest* release_compile();
-  ::rsh::server::protocol::CompileRequest* mutable_compile();
-  void set_allocated_compile(::rsh::server::protocol::CompileRequest* compile);
-  private:
-  const ::rsh::server::protocol::CompileRequest& _internal_compile() const;
-  ::rsh::server::protocol::CompileRequest* _internal_mutable_compile();
-  public:
-  void unsafe_arena_set_allocated_compile(
-      ::rsh::server::protocol::CompileRequest* compile);
-  ::rsh::server::protocol::CompileRequest* unsafe_arena_release_compile();
-
-  void clear_payload();
-  PayloadCase payload_case() const;
-  // @@protoc_insertion_point(class_scope:rsh.server.protocol.Request)
- private:
-  class _Internal;
-  void set_has_handshake();
-  void set_has_compile();
-
-  inline bool has_payload() const;
-  inline void clear_has_payload();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    union PayloadUnion {
-      constexpr PayloadUnion() : _constinit_{} {}
-        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-      ::rsh::server::protocol::HandshakeRequest* handshake_;
-      ::rsh::server::protocol::CompileRequest* compile_;
-    } payload_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    uint32_t _oneof_case_[1];
-
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_protocol_2eproto;
-};
-// -------------------------------------------------------------------
-
-class HandshakeRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.HandshakeRequest) */ {
- public:
-  inline HandshakeRequest() : HandshakeRequest(nullptr) {}
-  ~HandshakeRequest() override;
-  explicit PROTOBUF_CONSTEXPR HandshakeRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  HandshakeRequest(const HandshakeRequest& from);
-  HandshakeRequest(HandshakeRequest&& from) noexcept
-    : HandshakeRequest() {
-    *this = ::std::move(from);
-  }
-
-  inline HandshakeRequest& operator=(const HandshakeRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline HandshakeRequest& operator=(HandshakeRequest&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const HandshakeRequest& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const HandshakeRequest* internal_default_instance() {
-    return reinterpret_cast<const HandshakeRequest*>(
-               &_HandshakeRequest_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(HandshakeRequest& a, HandshakeRequest& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(HandshakeRequest* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(HandshakeRequest* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  HandshakeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<HandshakeRequest>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const HandshakeRequest& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const HandshakeRequest& from) {
-    HandshakeRequest::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(HandshakeRequest* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "rsh.server.protocol.HandshakeRequest";
-  }
-  protected:
-  explicit HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kPackagesFieldNumber = 4,
-    kRshVersionFieldNumber = 1,
-    kRVersionFieldNumber = 2,
-    kPlatformFieldNumber = 3,
-  };
-  // repeated string packages = 4;
-  int packages_size() const;
-  private:
-  int _internal_packages_size() const;
-  public:
-  void clear_packages();
-  const std::string& packages(int index) const;
-  std::string* mutable_packages(int index);
-  void set_packages(int index, const std::string& value);
-  void set_packages(int index, std::string&& value);
-  void set_packages(int index, const char* value);
-  void set_packages(int index, const char* value, size_t size);
-  std::string* add_packages();
-  void add_packages(const std::string& value);
-  void add_packages(std::string&& value);
-  void add_packages(const char* value);
-  void add_packages(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& packages() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_packages();
-  private:
-  const std::string& _internal_packages(int index) const;
-  std::string* _internal_add_packages();
-  public:
-
-  // string Rsh_version = 1;
-  void clear_rsh_version();
-  const std::string& rsh_version() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_rsh_version(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_rsh_version();
-  PROTOBUF_NODISCARD std::string* release_rsh_version();
-  void set_allocated_rsh_version(std::string* rsh_version);
-  private:
-  const std::string& _internal_rsh_version() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rsh_version(const std::string& value);
-  std::string* _internal_mutable_rsh_version();
-  public:
-
-  // string R_version = 2;
-  void clear_r_version();
-  const std::string& r_version() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_r_version(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_r_version();
-  PROTOBUF_NODISCARD std::string* release_r_version();
-  void set_allocated_r_version(std::string* r_version);
-  private:
-  const std::string& _internal_r_version() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_r_version(const std::string& value);
-  std::string* _internal_mutable_r_version();
-  public:
-
-  // string platform = 3;
-  void clear_platform();
-  const std::string& platform() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_platform(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_platform();
-  PROTOBUF_NODISCARD std::string* release_platform();
-  void set_allocated_platform(std::string* platform);
-  private:
-  const std::string& _internal_platform() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
-  std::string* _internal_mutable_platform();
-  public:
-
-  // @@protoc_insertion_point(class_scope:rsh.server.protocol.HandshakeRequest)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> packages_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rsh_version_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr r_version_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_protocol_2eproto;
-};
-// -------------------------------------------------------------------
-
-class CompileRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.CompileRequest) */ {
- public:
-  inline CompileRequest() : CompileRequest(nullptr) {}
-  ~CompileRequest() override;
-  explicit PROTOBUF_CONSTEXPR CompileRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  CompileRequest(const CompileRequest& from);
-  CompileRequest(CompileRequest&& from) noexcept
-    : CompileRequest() {
-    *this = ::std::move(from);
-  }
-
-  inline CompileRequest& operator=(const CompileRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline CompileRequest& operator=(CompileRequest&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const CompileRequest& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const CompileRequest* internal_default_instance() {
-    return reinterpret_cast<const CompileRequest*>(
-               &_CompileRequest_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(CompileRequest& a, CompileRequest& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(CompileRequest* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(CompileRequest* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  CompileRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CompileRequest>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CompileRequest& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CompileRequest& from) {
-    CompileRequest::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(CompileRequest* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "rsh.server.protocol.CompileRequest";
-  }
-  protected:
-  explicit CompileRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 2,
-    kClosureFieldNumber = 3,
-    kBcOptimizationFieldNumber = 4,
-    kCcOptimizationFieldNumber = 5,
-  };
-  // string name = 2;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // bytes closure = 3;
-  void clear_closure();
-  const std::string& closure() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_closure(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_closure();
-  PROTOBUF_NODISCARD std::string* release_closure();
-  void set_allocated_closure(std::string* closure);
-  private:
-  const std::string& _internal_closure() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_closure(const std::string& value);
-  std::string* _internal_mutable_closure();
-  public:
-
-  // uint32 bc_optimization = 4;
-  void clear_bc_optimization();
-  uint32_t bc_optimization() const;
-  void set_bc_optimization(uint32_t value);
-  private:
-  uint32_t _internal_bc_optimization() const;
-  void _internal_set_bc_optimization(uint32_t value);
-  public:
-
-  // uint32 cc_optimization = 5;
-  void clear_cc_optimization();
-  uint32_t cc_optimization() const;
-  void set_cc_optimization(uint32_t value);
-  private:
-  uint32_t _internal_cc_optimization() const;
-  void _internal_set_cc_optimization(uint32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:rsh.server.protocol.CompileRequest)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr closure_;
-    uint32_t bc_optimization_;
-    uint32_t cc_optimization_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_protocol_2eproto;
-};
-// -------------------------------------------------------------------
-
-class CompiledFunction final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.CompiledFunction) */ {
- public:
-  inline CompiledFunction() : CompiledFunction(nullptr) {}
-  ~CompiledFunction() override;
-  explicit PROTOBUF_CONSTEXPR CompiledFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  CompiledFunction(const CompiledFunction& from);
-  CompiledFunction(CompiledFunction&& from) noexcept
-    : CompiledFunction() {
-    *this = ::std::move(from);
-  }
-
-  inline CompiledFunction& operator=(const CompiledFunction& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline CompiledFunction& operator=(CompiledFunction&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const CompiledFunction& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const CompiledFunction* internal_default_instance() {
-    return reinterpret_cast<const CompiledFunction*>(
-               &_CompiledFunction_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(CompiledFunction& a, CompiledFunction& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(CompiledFunction* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(CompiledFunction* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  CompiledFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CompiledFunction>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CompiledFunction& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CompiledFunction& from) {
-    CompiledFunction::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(CompiledFunction* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "rsh.server.protocol.CompiledFunction";
-  }
-  protected:
-  explicit CompiledFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 2,
-    kNativeCodeFieldNumber = 3,
-    kConstantsFieldNumber = 4,
-  };
-  // string name = 2;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // bytes native_code = 3;
-  void clear_native_code();
-  const std::string& native_code() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_native_code(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_native_code();
-  PROTOBUF_NODISCARD std::string* release_native_code();
-  void set_allocated_native_code(std::string* native_code);
-  private:
-  const std::string& _internal_native_code() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_native_code(const std::string& value);
-  std::string* _internal_mutable_native_code();
-  public:
-
-  // bytes constants = 4;
-  void clear_constants();
-  const std::string& constants() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_constants(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_constants();
-  PROTOBUF_NODISCARD std::string* release_constants();
-  void set_allocated_constants(std::string* constants);
-  private:
-  const std::string& _internal_constants() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_constants(const std::string& value);
-  std::string* _internal_mutable_constants();
-  public:
-
-  // @@protoc_insertion_point(class_scope:rsh.server.protocol.CompiledFunction)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr native_code_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr constants_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_protocol_2eproto;
-};
-// -------------------------------------------------------------------
-
-class CompileResponse final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:rsh.server.protocol.CompileResponse) */ {
- public:
-  inline CompileResponse() : CompileResponse(nullptr) {}
-  ~CompileResponse() override;
-  explicit PROTOBUF_CONSTEXPR CompileResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  CompileResponse(const CompileResponse& from);
-  CompileResponse(CompileResponse&& from) noexcept
-    : CompileResponse() {
-    *this = ::std::move(from);
-  }
-
-  inline CompileResponse& operator=(const CompileResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline CompileResponse& operator=(CompileResponse&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const CompileResponse& default_instance() {
-    return *internal_default_instance();
-  }
-  enum DataCase {
-    kFailure = 2,
-    kResult = 3,
-    DATA_NOT_SET = 0,
-  };
-
-  static inline const CompileResponse* internal_default_instance() {
-    return reinterpret_cast<const CompileResponse*>(
-               &_CompileResponse_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    4;
-
-  friend void swap(CompileResponse& a, CompileResponse& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(CompileResponse* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(CompileResponse* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  CompileResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CompileResponse>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CompileResponse& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CompileResponse& from) {
-    CompileResponse::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(CompileResponse* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "rsh.server.protocol.CompileResponse";
-  }
-  protected:
-  explicit CompileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFailureFieldNumber = 2,
-    kResultFieldNumber = 3,
-  };
-  // string failure = 2;
-  bool has_failure() const;
-  private:
-  bool _internal_has_failure() const;
-  public:
-  void clear_failure();
-  const std::string& failure() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_failure(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_failure();
-  PROTOBUF_NODISCARD std::string* release_failure();
-  void set_allocated_failure(std::string* failure);
-  private:
-  const std::string& _internal_failure() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_failure(const std::string& value);
-  std::string* _internal_mutable_failure();
-  public:
-
-  // .rsh.server.protocol.CompiledFunction result = 3;
-  bool has_result() const;
-  private:
-  bool _internal_has_result() const;
-  public:
-  void clear_result();
-  const ::rsh::server::protocol::CompiledFunction& result() const;
-  PROTOBUF_NODISCARD ::rsh::server::protocol::CompiledFunction* release_result();
-  ::rsh::server::protocol::CompiledFunction* mutable_result();
-  void set_allocated_result(::rsh::server::protocol::CompiledFunction* result);
-  private:
-  const ::rsh::server::protocol::CompiledFunction& _internal_result() const;
-  ::rsh::server::protocol::CompiledFunction* _internal_mutable_result();
-  public:
-  void unsafe_arena_set_allocated_result(
-      ::rsh::server::protocol::CompiledFunction* result);
-  ::rsh::server::protocol::CompiledFunction* unsafe_arena_release_result();
-
-  void clear_data();
-  DataCase data_case() const;
-  // @@protoc_insertion_point(class_scope:rsh.server.protocol.CompileResponse)
- private:
-  class _Internal;
-  void set_has_failure();
-  void set_has_result();
-
-  inline bool has_data() const;
-  inline void clear_has_data();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    union DataUnion {
-      constexpr DataUnion() : _constinit_{} {}
-        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr failure_;
-      ::rsh::server::protocol::CompiledFunction* result_;
-    } data_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    uint32_t _oneof_case_[1];
-
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_protocol_2eproto;
-};
-// ===================================================================
-
-
-// ===================================================================
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif  // __GNUC__
-// Request
-
-// .rsh.server.protocol.HandshakeRequest handshake = 1;
-inline bool Request::_internal_has_handshake() const {
-  return payload_case() == kHandshake;
-}
-inline bool Request::has_handshake() const {
-  return _internal_has_handshake();
-}
-inline void Request::set_has_handshake() {
-  _impl_._oneof_case_[0] = kHandshake;
-}
-inline void Request::clear_handshake() {
-  if (_internal_has_handshake()) {
-    if (GetArenaForAllocation() == nullptr) {
-      delete _impl_.payload_.handshake_;
-    }
-    clear_has_payload();
-  }
-}
-inline ::rsh::server::protocol::HandshakeRequest* Request::release_handshake() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.Request.handshake)
-  if (_internal_has_handshake()) {
-    clear_has_payload();
-    ::rsh::server::protocol::HandshakeRequest* temp = _impl_.payload_.handshake_;
-    if (GetArenaForAllocation() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    _impl_.payload_.handshake_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::rsh::server::protocol::HandshakeRequest& Request::_internal_handshake() const {
-  return _internal_has_handshake()
-      ? *_impl_.payload_.handshake_
-      : reinterpret_cast< ::rsh::server::protocol::HandshakeRequest&>(::rsh::server::protocol::_HandshakeRequest_default_instance_);
-}
-inline const ::rsh::server::protocol::HandshakeRequest& Request::handshake() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.Request.handshake)
-  return _internal_handshake();
-}
-inline ::rsh::server::protocol::HandshakeRequest* Request::unsafe_arena_release_handshake() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.Request.handshake)
-  if (_internal_has_handshake()) {
-    clear_has_payload();
-    ::rsh::server::protocol::HandshakeRequest* temp = _impl_.payload_.handshake_;
-    _impl_.payload_.handshake_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void Request::unsafe_arena_set_allocated_handshake(::rsh::server::protocol::HandshakeRequest* handshake) {
-  clear_payload();
-  if (handshake) {
-    set_has_handshake();
-    _impl_.payload_.handshake_ = handshake;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.Request.handshake)
-}
-inline ::rsh::server::protocol::HandshakeRequest* Request::_internal_mutable_handshake() {
-  if (!_internal_has_handshake()) {
-    clear_payload();
-    set_has_handshake();
-    _impl_.payload_.handshake_ = CreateMaybeMessage< ::rsh::server::protocol::HandshakeRequest >(GetArenaForAllocation());
-  }
-  return _impl_.payload_.handshake_;
-}
-inline ::rsh::server::protocol::HandshakeRequest* Request::mutable_handshake() {
-  ::rsh::server::protocol::HandshakeRequest* _msg = _internal_mutable_handshake();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.Request.handshake)
-  return _msg;
-}
-
-// .rsh.server.protocol.CompileRequest compile = 2;
-inline bool Request::_internal_has_compile() const {
-  return payload_case() == kCompile;
-}
-inline bool Request::has_compile() const {
-  return _internal_has_compile();
-}
-inline void Request::set_has_compile() {
-  _impl_._oneof_case_[0] = kCompile;
-}
-inline void Request::clear_compile() {
-  if (_internal_has_compile()) {
-    if (GetArenaForAllocation() == nullptr) {
-      delete _impl_.payload_.compile_;
-    }
-    clear_has_payload();
-  }
-}
-inline ::rsh::server::protocol::CompileRequest* Request::release_compile() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.Request.compile)
-  if (_internal_has_compile()) {
-    clear_has_payload();
-    ::rsh::server::protocol::CompileRequest* temp = _impl_.payload_.compile_;
-    if (GetArenaForAllocation() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    _impl_.payload_.compile_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::rsh::server::protocol::CompileRequest& Request::_internal_compile() const {
-  return _internal_has_compile()
-      ? *_impl_.payload_.compile_
-      : reinterpret_cast< ::rsh::server::protocol::CompileRequest&>(::rsh::server::protocol::_CompileRequest_default_instance_);
-}
-inline const ::rsh::server::protocol::CompileRequest& Request::compile() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.Request.compile)
-  return _internal_compile();
-}
-inline ::rsh::server::protocol::CompileRequest* Request::unsafe_arena_release_compile() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.Request.compile)
-  if (_internal_has_compile()) {
-    clear_has_payload();
-    ::rsh::server::protocol::CompileRequest* temp = _impl_.payload_.compile_;
-    _impl_.payload_.compile_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void Request::unsafe_arena_set_allocated_compile(::rsh::server::protocol::CompileRequest* compile) {
-  clear_payload();
-  if (compile) {
-    set_has_compile();
-    _impl_.payload_.compile_ = compile;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.Request.compile)
-}
-inline ::rsh::server::protocol::CompileRequest* Request::_internal_mutable_compile() {
-  if (!_internal_has_compile()) {
-    clear_payload();
-    set_has_compile();
-    _impl_.payload_.compile_ = CreateMaybeMessage< ::rsh::server::protocol::CompileRequest >(GetArenaForAllocation());
-  }
-  return _impl_.payload_.compile_;
-}
-inline ::rsh::server::protocol::CompileRequest* Request::mutable_compile() {
-  ::rsh::server::protocol::CompileRequest* _msg = _internal_mutable_compile();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.Request.compile)
-  return _msg;
-}
-
-inline bool Request::has_payload() const {
-  return payload_case() != PAYLOAD_NOT_SET;
-}
-inline void Request::clear_has_payload() {
-  _impl_._oneof_case_[0] = PAYLOAD_NOT_SET;
-}
-inline Request::PayloadCase Request::payload_case() const {
-  return Request::PayloadCase(_impl_._oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// HandshakeRequest
-
-// string Rsh_version = 1;
-inline void HandshakeRequest::clear_rsh_version() {
-  _impl_.rsh_version_.ClearToEmpty();
-}
-inline const std::string& HandshakeRequest::rsh_version() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.Rsh_version)
-  return _internal_rsh_version();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void HandshakeRequest::set_rsh_version(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.rsh_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.Rsh_version)
-}
-inline std::string* HandshakeRequest::mutable_rsh_version() {
-  std::string* _s = _internal_mutable_rsh_version();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.Rsh_version)
-  return _s;
-}
-inline const std::string& HandshakeRequest::_internal_rsh_version() const {
-  return _impl_.rsh_version_.Get();
-}
-inline void HandshakeRequest::_internal_set_rsh_version(const std::string& value) {
-  
-  _impl_.rsh_version_.Set(value, GetArenaForAllocation());
-}
-inline std::string* HandshakeRequest::_internal_mutable_rsh_version() {
-  
-  return _impl_.rsh_version_.Mutable(GetArenaForAllocation());
-}
-inline std::string* HandshakeRequest::release_rsh_version() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.HandshakeRequest.Rsh_version)
-  return _impl_.rsh_version_.Release();
-}
-inline void HandshakeRequest::set_allocated_rsh_version(std::string* rsh_version) {
-  if (rsh_version != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.rsh_version_.SetAllocated(rsh_version, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.rsh_version_.IsDefault()) {
-    _impl_.rsh_version_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.Rsh_version)
-}
-
-// string R_version = 2;
-inline void HandshakeRequest::clear_r_version() {
-  _impl_.r_version_.ClearToEmpty();
-}
-inline const std::string& HandshakeRequest::r_version() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.R_version)
-  return _internal_r_version();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void HandshakeRequest::set_r_version(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.r_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.R_version)
-}
-inline std::string* HandshakeRequest::mutable_r_version() {
-  std::string* _s = _internal_mutable_r_version();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.R_version)
-  return _s;
-}
-inline const std::string& HandshakeRequest::_internal_r_version() const {
-  return _impl_.r_version_.Get();
-}
-inline void HandshakeRequest::_internal_set_r_version(const std::string& value) {
-  
-  _impl_.r_version_.Set(value, GetArenaForAllocation());
-}
-inline std::string* HandshakeRequest::_internal_mutable_r_version() {
-  
-  return _impl_.r_version_.Mutable(GetArenaForAllocation());
-}
-inline std::string* HandshakeRequest::release_r_version() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.HandshakeRequest.R_version)
-  return _impl_.r_version_.Release();
-}
-inline void HandshakeRequest::set_allocated_r_version(std::string* r_version) {
-  if (r_version != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.r_version_.SetAllocated(r_version, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.r_version_.IsDefault()) {
-    _impl_.r_version_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.R_version)
-}
-
-// string platform = 3;
-inline void HandshakeRequest::clear_platform() {
-  _impl_.platform_.ClearToEmpty();
-}
-inline const std::string& HandshakeRequest::platform() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.platform)
-  return _internal_platform();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void HandshakeRequest::set_platform(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.platform)
-}
-inline std::string* HandshakeRequest::mutable_platform() {
-  std::string* _s = _internal_mutable_platform();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.platform)
-  return _s;
-}
-inline const std::string& HandshakeRequest::_internal_platform() const {
-  return _impl_.platform_.Get();
-}
-inline void HandshakeRequest::_internal_set_platform(const std::string& value) {
-  
-  _impl_.platform_.Set(value, GetArenaForAllocation());
-}
-inline std::string* HandshakeRequest::_internal_mutable_platform() {
-  
-  return _impl_.platform_.Mutable(GetArenaForAllocation());
-}
-inline std::string* HandshakeRequest::release_platform() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.HandshakeRequest.platform)
-  return _impl_.platform_.Release();
-}
-inline void HandshakeRequest::set_allocated_platform(std::string* platform) {
-  if (platform != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.platform_.SetAllocated(platform, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.platform_.IsDefault()) {
-    _impl_.platform_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.HandshakeRequest.platform)
-}
-
-// repeated string packages = 4;
-inline int HandshakeRequest::_internal_packages_size() const {
-  return _impl_.packages_.size();
-}
-inline int HandshakeRequest::packages_size() const {
-  return _internal_packages_size();
-}
-inline void HandshakeRequest::clear_packages() {
-  _impl_.packages_.Clear();
-}
-inline std::string* HandshakeRequest::add_packages() {
-  std::string* _s = _internal_add_packages();
-  // @@protoc_insertion_point(field_add_mutable:rsh.server.protocol.HandshakeRequest.packages)
-  return _s;
-}
-inline const std::string& HandshakeRequest::_internal_packages(int index) const {
-  return _impl_.packages_.Get(index);
-}
-inline const std::string& HandshakeRequest::packages(int index) const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.HandshakeRequest.packages)
-  return _internal_packages(index);
-}
-inline std::string* HandshakeRequest::mutable_packages(int index) {
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.HandshakeRequest.packages)
-  return _impl_.packages_.Mutable(index);
-}
-inline void HandshakeRequest::set_packages(int index, const std::string& value) {
-  _impl_.packages_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline void HandshakeRequest::set_packages(int index, std::string&& value) {
-  _impl_.packages_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline void HandshakeRequest::set_packages(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.packages_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline void HandshakeRequest::set_packages(int index, const char* value, size_t size) {
-  _impl_.packages_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline std::string* HandshakeRequest::_internal_add_packages() {
-  return _impl_.packages_.Add();
-}
-inline void HandshakeRequest::add_packages(const std::string& value) {
-  _impl_.packages_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline void HandshakeRequest::add_packages(std::string&& value) {
-  _impl_.packages_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline void HandshakeRequest::add_packages(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.packages_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline void HandshakeRequest::add_packages(const char* value, size_t size) {
-  _impl_.packages_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:rsh.server.protocol.HandshakeRequest.packages)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-HandshakeRequest::packages() const {
-  // @@protoc_insertion_point(field_list:rsh.server.protocol.HandshakeRequest.packages)
-  return _impl_.packages_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-HandshakeRequest::mutable_packages() {
-  // @@protoc_insertion_point(field_mutable_list:rsh.server.protocol.HandshakeRequest.packages)
-  return &_impl_.packages_;
-}
-
-// -------------------------------------------------------------------
-
-// CompileRequest
-
-// string name = 2;
-inline void CompileRequest::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& CompileRequest::name() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CompileRequest::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.name)
-}
-inline std::string* CompileRequest::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileRequest.name)
-  return _s;
-}
-inline const std::string& CompileRequest::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void CompileRequest::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompileRequest::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CompileRequest::release_name() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileRequest.name)
-  return _impl_.name_.Release();
-}
-inline void CompileRequest::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileRequest.name)
-}
-
-// bytes closure = 3;
-inline void CompileRequest::clear_closure() {
-  _impl_.closure_.ClearToEmpty();
-}
-inline const std::string& CompileRequest::closure() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.closure)
-  return _internal_closure();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CompileRequest::set_closure(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.closure_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.closure)
-}
-inline std::string* CompileRequest::mutable_closure() {
-  std::string* _s = _internal_mutable_closure();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileRequest.closure)
-  return _s;
-}
-inline const std::string& CompileRequest::_internal_closure() const {
-  return _impl_.closure_.Get();
-}
-inline void CompileRequest::_internal_set_closure(const std::string& value) {
-  
-  _impl_.closure_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompileRequest::_internal_mutable_closure() {
-  
-  return _impl_.closure_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CompileRequest::release_closure() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileRequest.closure)
-  return _impl_.closure_.Release();
-}
-inline void CompileRequest::set_allocated_closure(std::string* closure) {
-  if (closure != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.closure_.SetAllocated(closure, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.closure_.IsDefault()) {
-    _impl_.closure_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileRequest.closure)
-}
-
-// uint32 bc_optimization = 4;
-inline void CompileRequest::clear_bc_optimization() {
-  _impl_.bc_optimization_ = 0u;
-}
-inline uint32_t CompileRequest::_internal_bc_optimization() const {
-  return _impl_.bc_optimization_;
-}
-inline uint32_t CompileRequest::bc_optimization() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.bc_optimization)
-  return _internal_bc_optimization();
-}
-inline void CompileRequest::_internal_set_bc_optimization(uint32_t value) {
-  
-  _impl_.bc_optimization_ = value;
-}
-inline void CompileRequest::set_bc_optimization(uint32_t value) {
-  _internal_set_bc_optimization(value);
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.bc_optimization)
-}
-
-// uint32 cc_optimization = 5;
-inline void CompileRequest::clear_cc_optimization() {
-  _impl_.cc_optimization_ = 0u;
-}
-inline uint32_t CompileRequest::_internal_cc_optimization() const {
-  return _impl_.cc_optimization_;
-}
-inline uint32_t CompileRequest::cc_optimization() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileRequest.cc_optimization)
-  return _internal_cc_optimization();
-}
-inline void CompileRequest::_internal_set_cc_optimization(uint32_t value) {
-  
-  _impl_.cc_optimization_ = value;
-}
-inline void CompileRequest::set_cc_optimization(uint32_t value) {
-  _internal_set_cc_optimization(value);
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileRequest.cc_optimization)
-}
-
-// -------------------------------------------------------------------
-
-// CompiledFunction
-
-// string name = 2;
-inline void CompiledFunction::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& CompiledFunction::name() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompiledFunction.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CompiledFunction::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompiledFunction.name)
-}
-inline std::string* CompiledFunction::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompiledFunction.name)
-  return _s;
-}
-inline const std::string& CompiledFunction::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void CompiledFunction::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompiledFunction::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CompiledFunction::release_name() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompiledFunction.name)
-  return _impl_.name_.Release();
-}
-inline void CompiledFunction::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.name)
-}
-
-// bytes native_code = 3;
-inline void CompiledFunction::clear_native_code() {
-  _impl_.native_code_.ClearToEmpty();
-}
-inline const std::string& CompiledFunction::native_code() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompiledFunction.native_code)
-  return _internal_native_code();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CompiledFunction::set_native_code(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.native_code_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompiledFunction.native_code)
-}
-inline std::string* CompiledFunction::mutable_native_code() {
-  std::string* _s = _internal_mutable_native_code();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompiledFunction.native_code)
-  return _s;
-}
-inline const std::string& CompiledFunction::_internal_native_code() const {
-  return _impl_.native_code_.Get();
-}
-inline void CompiledFunction::_internal_set_native_code(const std::string& value) {
-  
-  _impl_.native_code_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompiledFunction::_internal_mutable_native_code() {
-  
-  return _impl_.native_code_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CompiledFunction::release_native_code() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompiledFunction.native_code)
-  return _impl_.native_code_.Release();
-}
-inline void CompiledFunction::set_allocated_native_code(std::string* native_code) {
-  if (native_code != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.native_code_.SetAllocated(native_code, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.native_code_.IsDefault()) {
-    _impl_.native_code_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.native_code)
-}
-
-// bytes constants = 4;
-inline void CompiledFunction::clear_constants() {
-  _impl_.constants_.ClearToEmpty();
-}
-inline const std::string& CompiledFunction::constants() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompiledFunction.constants)
-  return _internal_constants();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CompiledFunction::set_constants(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.constants_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompiledFunction.constants)
-}
-inline std::string* CompiledFunction::mutable_constants() {
-  std::string* _s = _internal_mutable_constants();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompiledFunction.constants)
-  return _s;
-}
-inline const std::string& CompiledFunction::_internal_constants() const {
-  return _impl_.constants_.Get();
-}
-inline void CompiledFunction::_internal_set_constants(const std::string& value) {
-  
-  _impl_.constants_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompiledFunction::_internal_mutable_constants() {
-  
-  return _impl_.constants_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CompiledFunction::release_constants() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompiledFunction.constants)
-  return _impl_.constants_.Release();
-}
-inline void CompiledFunction::set_allocated_constants(std::string* constants) {
-  if (constants != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.constants_.SetAllocated(constants, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.constants_.IsDefault()) {
-    _impl_.constants_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompiledFunction.constants)
-}
-
-// -------------------------------------------------------------------
-
-// CompileResponse
-
-// string failure = 2;
-inline bool CompileResponse::_internal_has_failure() const {
-  return data_case() == kFailure;
-}
-inline bool CompileResponse::has_failure() const {
-  return _internal_has_failure();
-}
-inline void CompileResponse::set_has_failure() {
-  _impl_._oneof_case_[0] = kFailure;
-}
-inline void CompileResponse::clear_failure() {
-  if (_internal_has_failure()) {
-    _impl_.data_.failure_.Destroy();
-    clear_has_data();
-  }
-}
-inline const std::string& CompileResponse::failure() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileResponse.failure)
-  return _internal_failure();
-}
-template <typename ArgT0, typename... ArgT>
-inline void CompileResponse::set_failure(ArgT0&& arg0, ArgT... args) {
-  if (!_internal_has_failure()) {
-    clear_data();
-    set_has_failure();
-    _impl_.data_.failure_.InitDefault();
-  }
-  _impl_.data_.failure_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:rsh.server.protocol.CompileResponse.failure)
-}
-inline std::string* CompileResponse::mutable_failure() {
-  std::string* _s = _internal_mutable_failure();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileResponse.failure)
-  return _s;
-}
-inline const std::string& CompileResponse::_internal_failure() const {
-  if (_internal_has_failure()) {
-    return _impl_.data_.failure_.Get();
-  }
-  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void CompileResponse::_internal_set_failure(const std::string& value) {
-  if (!_internal_has_failure()) {
-    clear_data();
-    set_has_failure();
-    _impl_.data_.failure_.InitDefault();
-  }
-  _impl_.data_.failure_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CompileResponse::_internal_mutable_failure() {
-  if (!_internal_has_failure()) {
-    clear_data();
-    set_has_failure();
-    _impl_.data_.failure_.InitDefault();
-  }
-  return _impl_.data_.failure_.Mutable(      GetArenaForAllocation());
-}
-inline std::string* CompileResponse::release_failure() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileResponse.failure)
-  if (_internal_has_failure()) {
-    clear_has_data();
-    return _impl_.data_.failure_.Release();
-  } else {
-    return nullptr;
-  }
-}
-inline void CompileResponse::set_allocated_failure(std::string* failure) {
-  if (has_data()) {
-    clear_data();
-  }
-  if (failure != nullptr) {
-    set_has_failure();
-    _impl_.data_.failure_.InitAllocated(failure, GetArenaForAllocation());
-  }
-  // @@protoc_insertion_point(field_set_allocated:rsh.server.protocol.CompileResponse.failure)
-}
-
-// .rsh.server.protocol.CompiledFunction result = 3;
-inline bool CompileResponse::_internal_has_result() const {
-  return data_case() == kResult;
-}
-inline bool CompileResponse::has_result() const {
-  return _internal_has_result();
-}
-inline void CompileResponse::set_has_result() {
-  _impl_._oneof_case_[0] = kResult;
-}
-inline void CompileResponse::clear_result() {
-  if (_internal_has_result()) {
-    if (GetArenaForAllocation() == nullptr) {
-      delete _impl_.data_.result_;
-    }
-    clear_has_data();
-  }
-}
-inline ::rsh::server::protocol::CompiledFunction* CompileResponse::release_result() {
-  // @@protoc_insertion_point(field_release:rsh.server.protocol.CompileResponse.result)
-  if (_internal_has_result()) {
-    clear_has_data();
-    ::rsh::server::protocol::CompiledFunction* temp = _impl_.data_.result_;
-    if (GetArenaForAllocation() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    _impl_.data_.result_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::rsh::server::protocol::CompiledFunction& CompileResponse::_internal_result() const {
-  return _internal_has_result()
-      ? *_impl_.data_.result_
-      : reinterpret_cast< ::rsh::server::protocol::CompiledFunction&>(::rsh::server::protocol::_CompiledFunction_default_instance_);
-}
-inline const ::rsh::server::protocol::CompiledFunction& CompileResponse::result() const {
-  // @@protoc_insertion_point(field_get:rsh.server.protocol.CompileResponse.result)
-  return _internal_result();
-}
-inline ::rsh::server::protocol::CompiledFunction* CompileResponse::unsafe_arena_release_result() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:rsh.server.protocol.CompileResponse.result)
-  if (_internal_has_result()) {
-    clear_has_data();
-    ::rsh::server::protocol::CompiledFunction* temp = _impl_.data_.result_;
-    _impl_.data_.result_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void CompileResponse::unsafe_arena_set_allocated_result(::rsh::server::protocol::CompiledFunction* result) {
-  clear_data();
-  if (result) {
-    set_has_result();
-    _impl_.data_.result_ = result;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:rsh.server.protocol.CompileResponse.result)
-}
-inline ::rsh::server::protocol::CompiledFunction* CompileResponse::_internal_mutable_result() {
-  if (!_internal_has_result()) {
-    clear_data();
-    set_has_result();
-    _impl_.data_.result_ = CreateMaybeMessage< ::rsh::server::protocol::CompiledFunction >(GetArenaForAllocation());
-  }
-  return _impl_.data_.result_;
-}
-inline ::rsh::server::protocol::CompiledFunction* CompileResponse::mutable_result() {
-  ::rsh::server::protocol::CompiledFunction* _msg = _internal_mutable_result();
-  // @@protoc_insertion_point(field_mutable:rsh.server.protocol.CompileResponse.result)
-  return _msg;
-}
-
-inline bool CompileResponse::has_data() const {
-  return data_case() != DATA_NOT_SET;
-}
-inline void CompileResponse::clear_has_data() {
-  _impl_._oneof_case_[0] = DATA_NOT_SET;
-}
-inline CompileResponse::DataCase CompileResponse::data_case() const {
-  return CompileResponse::DataCase(_impl_._oneof_case_[0]);
-}
-#ifdef __GNUC__
-  #pragma GCC diagnostic pop
-#endif  // __GNUC__
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace protocol
-}  // namespace server
-}  // namespace rsh
-
-// @@protoc_insertion_point(global_scope)
-
-#include <google/protobuf/port_undef.inc>
-#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protocol_2eproto
diff --git a/server/.jqwik-database b/server/.jqwik-database
index 711006c3d3b5c6d50049e3f48311f3dbe372803d..7bd2b58bd0d2d412c81be18b25088244606f048e 100644
GIT binary patch
literal 1086
zcmeH`ziSjh6vy9g5`~zH!5^Jz#KIuXlH0@cE+7~SIa#83sSHskyU%sv-t64W+hor|
z5X8n-!GQh;Dee3N?EMSuMJp}roS7425U#bcnVH@B&gXq*;O&2b8KdE>L}J^+UGa#a
z%!NdzF)ei_WX{&n(Ctc=clN&BxYBwZ!c-3$hB#H`rc3Z5f%zOIYEGh*J^7#{xR6+4
z<cZOk7-5ZR<r2~LL*W&Bypm#AVK3{Gwj~KpB-?z4M+KL8H2$|zD*y<s>(XDYzsc+{
z`Q48rp9iPk-}TDJ|5VJdPN1<hBJ86rEK_?&SQr<zjzyFRLso27bD5QcK4Lb6ClGpx
z%U0r~^J6Z`u4>IkE?+<WxVZO$zny}h2h&D8MjsD$r>%Kl9N?&3W&S&}ka-Vrmt?C}
z<;~jtXJ2o9KNCW*3Nt&rsIb<sa1dIn23x3~@4s3+_VUw<5Ww;sb<VSA1Hb-1z}&<)
zXiVIleD>e(HtL$-)WvpZxfREqR@`pJ%dK|vQnN##HpZ>i^?kP)ZKMS^rd#TqDP1T#
x3C(DvkR_Z*r081P*qqX(LQSKtFxSe5s8Q0rUy<_%-Nuz*>y;|-oFC(*&7TY>D%=17

literal 4
LcmZ4UmVp%j1%Lsc

diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 68ce31b6c..abfd92b60 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -59,7 +59,12 @@ public void compile(
 
     // Parse the request
     Messages.Function function = request.getFunction();
-    Messages.Tier tier = request.getTier(); // Default is baseline
+    Messages.Tier tier = request.getTier(); // Default is optimized
+    if (tier == Messages.Tier.UNRECOGNIZED) {
+      tier = Messages.Tier.OPTIMIZED;
+    }
+    var bcOpt = request.hasBcOpt() ? request.getBcOpt() : 2;
+    var ccOpt = request.hasCcOpt() ? request.getCcOpt() : 2;
     Messages.Context context = request.getContext(); // null if not provided
 
     logger.info(
@@ -68,9 +73,9 @@ public void compile(
             + " at tier "
             + tier
             + " with bytecode level "
-            + request.getBcOpt()
+            + (request.hasBcOpt() ? bcOpt : "default 2")
             + " and native optimization level "
-            + request.getCcOpt());
+            + (request.hasCcOpt() ? ccOpt : "default 2"));
 
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
@@ -79,7 +84,7 @@ public void compile(
 
     // Cache requests
     NativeClosure ccCached = null;
-    var nativeKey = Triple.of(function.getHash(), request.getBcOpt(), request.getCcOpt());
+    var nativeKey = Triple.of(function.getHash(), bcOpt, ccOpt);
     if (tier.equals(Messages.Tier.OPTIMIZED)) {
       ccCached = nativeCache.get(nativeKey);
       if (ccCached != null) {
@@ -91,7 +96,7 @@ public void compile(
 
     Pair<Bc, ByteString> bcCached = null;
     // We also have a look whether we have a cached bytecode for the native compilation
-    var bcKey = Pair.of(function.getHash(), request.getBcOpt());
+    var bcKey = Pair.of(function.getHash(), bcOpt);
     if (tier.equals((Messages.Tier.BASELINE)) || ccCached == null) {
       bcCached = bcCache.get(bcKey);
       if (bcCached != null) {
@@ -117,10 +122,10 @@ public void compile(
             "Compile function "
                 + function.getName()
                 + " to bytecode with optimisation level "
-                + request.getBcOpt()
+                + bcOpt
                 + ": not found in cache.");
         try {
-          var bc = compileBcClosure(function.getBody(), request.getBcOpt());
+          var bc = compileBcClosure(function.getBody(), bcOpt);
           ByteString serializedBc = RDSWriter.writeByteString(SEXPs.bcode(bc));
           response.setCode(serializedBc);
           bcCached = Pair.of(bc, serializedBc); // potentially used for the native compilation also
@@ -146,9 +151,9 @@ public void compile(
             "Compile function "
                 + function.getName()
                 + " with optimisation level "
-                + request.getBcOpt()
+                + bcOpt
                 + " and native level "
-                + request.getCcOpt()
+                + ccOpt
                 + ": not found in cache.");
         // At this point, we have already the bytecode, whether we got it from the cache or we
         // compiled it
@@ -163,7 +168,7 @@ public void compile(
           module.file().writeTo(f);
           var output = File.createTempFile("ofile", ".o");
 
-          RshCompiler.getInstance(request.getCcOpt())
+          RshCompiler.getInstance(ccOpt)
               .createBuilder(input.getPath(), output.getPath())
               .flag("-c")
               .compile();

From 2b4d06974909ea8f45daf3047e0f3d3aea721f3c Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 4 Oct 2024 15:07:28 +0200
Subject: [PATCH 69/80] Benchmakrs now run correctly~

---
 client/rsh/R/rsh.R                                         | 7 +++++--
 client/rsh/src/client.cpp                                  | 7 ++++---
 client/rsh/src/client.hpp                                  | 1 +
 server/src/main/java/org/prlprg/server/CompileService.java | 7 ++++++-
 4 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/client/rsh/R/rsh.R b/client/rsh/R/rsh.R
index 5240283d4..bf691bccf 100644
--- a/client/rsh/R/rsh.R
+++ b/client/rsh/R/rsh.R
@@ -6,6 +6,7 @@ NULL
 # save the original compiler::cmpfun
 .gnur_cmpfun <- compiler::cmpfun
 
+
 # Because of the ORC JIT we need all the native symbols registered globally
 # (as RTLD_GLOBAL) so the ORC linker can find them. Unfortunatelly, R does
 # not provide a way to instruct the namespace loader to load pass the
@@ -31,7 +32,9 @@ NULL
   )
 
   .Call(C_initialize)
-  init_client("0.0.0.0", 8980L)
+
+   # for the client, so that it is not GC-ed
+  env[[".rsh_client"]] <- init_client("0.0.0.0", 8980L)
 }
 
 #' Initialize the Rsh client
@@ -40,7 +43,7 @@ NULL
 #' @param port port of the server
 #' @export
 init_client <- function(address="0.0.0.0", port=8980L) {
-  .Call(C_init_client, address, port, installed.packages()[,1])
+  .rsh_client <- .Call(C_init_client, address, port, installed.packages()[,1])
 }
 
 #' Activate the Rsh JIT
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 0a4b72fbc..8be9eb553 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -91,8 +91,9 @@ SEXP Client::make_client(SEXP address, SEXP port, SEXP installed_packages) {
   auto client = new Client(channel, packages);
 
 
-  SEXP ptr =  PROTECT(R_MakeExternalPtr(client, Rf_install("RSH_CLIENT"), R_NilValue));
-  //R_RegisterCFinalizerEx(ptr, &Client::remove_client, TRUE);// TRUE because we want to shutdown the client when R quits
+  SEXP ptr =  PROTECT(R_MakeExternalPtr(client, RSH_CLIENT_PTR, R_NilValue));
+  // Removed because it was causing a segfault (memory not mapped)
+  //R_RegisterCFinalizerEx(ptr, &Client::remove_client, FALSE);// TRUE because we want to shutdown the client when R quits
 
   UNPROTECT(1);
   return ptr;
@@ -122,7 +123,7 @@ SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
 
   Client::CLIENT_INSTANCE = Client::make_client(address, port, installed_packages);
 
-  return R_NilValue;
+  return Client::CLIENT_INSTANCE;
 }
 
 } // namespace rsh
diff --git a/client/rsh/src/client.hpp b/client/rsh/src/client.hpp
index 474b805fe..07f6dd646 100644
--- a/client/rsh/src/client.hpp
+++ b/client/rsh/src/client.hpp
@@ -22,6 +22,7 @@ class Client {
 private:
   std::unique_ptr<protocol::CompileService::Stub> stub_;
   static inline SEXP CLIENT_INSTANCE = nullptr;
+  static inline SEXP RSH_CLIENT_PTR = Rf_install("RSH_CLIENT");
   static void remove_client(SEXP ptr);
 
   // For it to be able to access the client instance
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index abfd92b60..5834bf374 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -43,7 +43,10 @@ class CompileService extends CompileServiceGrpc.CompileServiceImplBase {
       new HashMap<>();
 
   private static String genSymbol(Messages.Function function) {
-    return "gen_" + function.getHash();
+    // the hash is uint64 (unsigned ) but java does not have unsigned numbers and store it as a long
+    // We first need to convert it to a string and interpret it as an unsigned number
+    // Java uses 2's complement
+    return "gen_" + Long.toUnsignedString(function.getHash());
   }
 
   // Testing externally: grpcurl -plaintext -d '{"function":{"name": "testFunc"}}' 0.0.0.0:8980
@@ -70,6 +73,8 @@ public void compile(
     logger.info(
         "Received request to compile function "
             + function.getName()
+            + " with hash "
+            + Long.toUnsignedString(function.getHash())
             + " at tier "
             + tier
             + " with bytecode level "

From e3fac46a755bff52d3c2a9d398753a6f4469f083 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 4 Oct 2024 17:42:22 +0200
Subject: [PATCH 70/80] Fix RDS writer tests.

A merge had removed the correct version of eval(String source, SEXP input)
---
 server/.jqwik-database                           | Bin 1086 -> 4 bytes
 .../test/java/org/prlprg/util/GNURFactory.java   |   2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/.jqwik-database b/server/.jqwik-database
index 7bd2b58bd0d2d412c81be18b25088244606f048e..711006c3d3b5c6d50049e3f48311f3dbe372803d 100644
GIT binary patch
literal 4
LcmZ4UmVp%j1%Lsc

literal 1086
zcmeH`ziSjh6vy9g5`~zH!5^Jz#KIuXlH0@cE+7~SIa#83sSHskyU%sv-t64W+hor|
z5X8n-!GQh;Dee3N?EMSuMJp}roS7425U#bcnVH@B&gXq*;O&2b8KdE>L}J^+UGa#a
z%!NdzF)ei_WX{&n(Ctc=clN&BxYBwZ!c-3$hB#H`rc3Z5f%zOIYEGh*J^7#{xR6+4
z<cZOk7-5ZR<r2~LL*W&Bypm#AVK3{Gwj~KpB-?z4M+KL8H2$|zD*y<s>(XDYzsc+{
z`Q48rp9iPk-}TDJ|5VJdPN1<hBJ86rEK_?&SQr<zjzyFRLso27bD5QcK4Lb6ClGpx
z%U0r~^J6Z`u4>IkE?+<WxVZO$zny}h2h&D8MjsD$r>%Kl9N?&3W&S&}ka-Vrmt?C}
z<;~jtXJ2o9KNCW*3Nt&rsIb<sa1dIn23x3~@4s3+_VUw<5Ww;sb<VSA1Hb-1z}&<)
zXiVIleD>e(HtL$-)WvpZxfREqR@`pJ%dK|vQnN##HpZ>i^?kP)ZKMS^rd#TqDP1T#
x3C(DvkR_Z*r081P*qqX(LQSKtFxSe5s8Q0rUy<_%-Nuz*>y;|-oFC(*&7TY>D%=17

diff --git a/server/src/test/java/org/prlprg/util/GNURFactory.java b/server/src/test/java/org/prlprg/util/GNURFactory.java
index 31e2cadcd..a78176974 100644
--- a/server/src/test/java/org/prlprg/util/GNURFactory.java
+++ b/server/src/test/java/org/prlprg/util/GNURFactory.java
@@ -100,7 +100,7 @@ public Pair<SEXP, String> capturingEval(String source) {
   public SEXP eval(String source, SEXP input) {
     check();
     assert R != null;
-    return R.eval(source);
+    return R.eval(source, input);
   }
 
   @Override

From ddff33fdb577c72337892154990568dd7ca6dbfd Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 10 Oct 2024 13:24:00 +0200
Subject: [PATCH 71/80] FIX: for in-place bytecode compilation, the bytecode
 body was wrongly replaced by a native code wrapper body

---
 client/rsh/src/compiler.cpp |  5 ++++-
 tools/compile-package.R     | 26 ++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)
 create mode 100644 tools/compile-package.R

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index ae3dc09d7..42281f85f 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -219,8 +219,11 @@ SEXP compile(SEXP closure, SEXP options) {
 
   // Inplace or not (i.e. through through an explicit call to `compile` or through the R JIT)
   if (opts.inplace) {
-    body = PROTECT(create_wrapper_body(closure, c_cp));
+    if(opts.tier == protocol::Tier::OPTIMIZED) {
+       body = PROTECT(create_wrapper_body(closure, c_cp));
+    }
     SET_BODY(closure, body);
+    UNPROTECT(1);
     // FIXME: add logging primitives
     Rprintf("Compiled in place fun %s (fun=%p, body=%p) ; ",
             opts.name.c_str(), closure,
diff --git a/tools/compile-package.R b/tools/compile-package.R
new file mode 100644
index 000000000..1a1586543
--- /dev/null
+++ b/tools/compile-package.R
@@ -0,0 +1,26 @@
+#! /usr/bin/env Rscript
+
+# Compile all the functions in a package
+# Report the ones that do not compile
+
+args = commandArgs(trailingOnly=TRUE)
+
+
+package <- if(length(args) == 0) {
+    stop("At least one argument must be provided")
+} else {
+    args[[1]]
+}
+
+library(package, character.only=TRUE)
+
+ns <- getNamespace(package)
+
+# Only compile closures
+for(v in ls(ns)) {
+    if(typeof(ns[[v]]) == "closure") {
+        f <- ns[[v]]
+        cat("Compiling ", v, "\n")
+        rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
+    }
+}
\ No newline at end of file

From 9b091cc8bea8c04fbb44d1f4c71b12d4adf0fec7 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 10 Oct 2024 17:35:53 +0200
Subject: [PATCH 72/80] Fix path problems + script to compile all the closures
 in a package

---
 .../java/org/prlprg/session/GNURSession.java  | 46 +++++++++++--------
 .../org/prlprg/session/PackageDatabase.java   |  7 ++-
 .../org/prlprg/rsession/GNURSessionTest.java  |  4 ++
 tools/compile-package.R                       | 43 ++++++++++++++---
 4 files changed, 69 insertions(+), 31 deletions(-)

diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index 98527a656..2c5c7142b 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -4,10 +4,7 @@
 import java.io.IOException;
 import java.net.URI;
 import java.nio.file.Path;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
@@ -72,7 +69,7 @@ public class GNURSession implements RSession {
   private URI cranMirror;
   private org.prlprg.RVersion RVersion;
   private final Path RDir;
-  private final Path RLibraries;
+  private final List<Path> RLibraries;
 
   private @Nullable BaseEnvSXP baseEnv = null;
   private @Nullable NamespaceEnvSXP baseNamespace = null;
@@ -89,7 +86,7 @@ public GNURSession(RVersion version, Path r_dir, Path r_libraries) {
     cranMirror = URI.create("https://cran.r-project.org");
     RVersion = version;
     RDir = r_dir;
-    RLibraries = r_libraries;
+    RLibraries = Arrays.asList(RDir.resolve("library"), r_libraries);
   }
 
   public GNURSession(RVersion version, Path r_dir, Path r_libraries, URI cranMirror) {
@@ -99,13 +96,23 @@ public GNURSession(RVersion version, Path r_dir, Path r_libraries, URI cranMirro
 
   public void setCranMirror(URI uri) {}
 
+  private @Nullable Path resolvePaths(String name) {
+    for (var p : RLibraries) {
+      var pkgPath = p.resolve(name);
+      var pkgDir = pkgPath.toFile();
+      if (pkgDir.exists() && pkgDir.isDirectory()) {
+        return pkgPath;
+      }
+    }
+    return null;
+  }
+
   // We should also handle installation of a package from a GitHub repo?
   public void loadPackage(String name, String version) {
-    var pkgPath = RLibraries.resolve(name);
-    var pkgDir = pkgPath.toFile();
-    // Check if package is installed and if not install it
-    if (!pkgDir.exists() || !pkgDir.isDirectory()) {
+    @Nullable var pkgDir = resolvePaths(name);
+    if (pkgDir == null) {
       installPackage(name);
+      pkgDir = resolvePaths(name);
     }
 
     DESCRIPTION description = getDescription(name);
@@ -130,7 +137,8 @@ public void loadPackage(String name, String version) {
 
     // Load the package
     try {
-      var bindings = readPackageDatabase(this, RLibraries, name);
+      // getParent() because we add the name of the package to the path in readPackageDatabase
+      var bindings = readPackageDatabase(this, pkgDir.getParent(), name);
       var ns = namespaces.get(name + version);
       ns.setBindings(bindings);
     } catch (IOException e) {
@@ -139,8 +147,7 @@ public void loadPackage(String name, String version) {
   }
 
   private void installPackage(String name) {
-    var pkgPath = RLibraries.resolve(name);
-    var pkgDir = pkgPath.toFile();
+    var pkgDir = resolvePaths(name);
 
     var RScript = RDir.resolve("bin/Rscript");
     try {
@@ -161,17 +168,16 @@ private void installPackage(String name) {
   }
 
   private DESCRIPTION getDescription(String name) {
-    var pkgPath = RLibraries.resolve(name);
-    var pkgDir = pkgPath.toFile();
-
-    Path descriptionFile = pkgPath.resolve("DESCRIPTION");
-    DESCRIPTION description;
     try {
+      var pkgDir = resolvePaths(name);
+
+      Path descriptionFile = pkgDir.toAbsolutePath().resolve("DESCRIPTION");
+      DESCRIPTION description;
       description = new DESCRIPTION(descriptionFile);
-    } catch (IOException e) {
+      return description;
+    } catch (Exception e) {
       throw new RuntimeException(e);
     }
-    return description;
   }
 
   private static HashMap<String, SEXP> readPackageDatabase(
diff --git a/server/src/main/java/org/prlprg/session/PackageDatabase.java b/server/src/main/java/org/prlprg/session/PackageDatabase.java
index 71e2da3b0..ac1571d0c 100644
--- a/server/src/main/java/org/prlprg/session/PackageDatabase.java
+++ b/server/src/main/java/org/prlprg/session/PackageDatabase.java
@@ -171,15 +171,14 @@ private static UserEnvSXP vecToEnv(VecSXP v) {
   /**
    * Create a new package database.
    *
-   * @param libraryPath The path to the library where the package is installed.
+   * @param pkgDir The path to the library where the package is installed.
    * @param packageName The name of the package.
    */
-  public PackageDatabase(RSession session, Path libraryPath, String packageName)
-      throws IOException {
+  public PackageDatabase(RSession session, Path pkgDir, String packageName) throws IOException {
     this.session = session;
     // .libPaths and installed_packages() in R can help to see
     // where packages are installed
-    var basePath = libraryPath.resolve(packageName + "/R");
+    var basePath = pkgDir.resolve(packageName + "/R");
     // Read the index file .rdx
     // we get a list with 3 elements, variables, references and compressed
     // See LazyLoading in https://cran.r-project.org/doc/manuals/r-devel/R-ints.html
diff --git a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
index f3c0a33e0..f89ea4ffd 100644
--- a/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
+++ b/server/src/test/java/org/prlprg/rsession/GNURSessionTest.java
@@ -14,6 +14,10 @@ public class GNURSessionTest {
   private static final Path libDir = Path.of("../external/R/library/");
   @TempDir Path tempDir;
 
+  static {
+    System.out.println(new java.io.File("").getAbsolutePath());
+  }
+
   @Test
   public void testReadPackageDatabase() throws IOException {
     var session = new GNURSession(RVersion.LATEST_AWARE, RDir, libDir);
diff --git a/tools/compile-package.R b/tools/compile-package.R
index 1a1586543..b172e6819 100644
--- a/tools/compile-package.R
+++ b/tools/compile-package.R
@@ -3,24 +3,53 @@
 # Compile all the functions in a package
 # Report the ones that do not compile
 
-args = commandArgs(trailingOnly=TRUE)
+# For yaml
+# LD_PRELOAD=/usr/lib/llvm-17/lib/libLLVM-17.so ../external/R/bin/Rscript compile-package.R yaml
 
+args <- commandArgs(trailingOnly = TRUE)
 
-package <- if(length(args) == 0) {
+
+package <- if (length(args) == 0) {
     stop("At least one argument must be provided")
 } else {
     args[[1]]
 }
 
-library(package, character.only=TRUE)
+cat(
+    "Compiling package ", package, " at version ",
+    as.character(packageVersion(package)), "\n"
+)
+
+library(package, character.only = TRUE)
 
 ns <- getNamespace(package)
 
+nb_comps <- 0
+not_compiled <- character(0)    
+
 # Only compile closures
-for(v in ls(ns)) {
-    if(typeof(ns[[v]]) == "closure") {
-        f <- ns[[v]]
+for (v in ls(ns)) {
+    f <- ns[[v]]
+    if (typeof(f) == "closure") {
+        
         cat("Compiling ", v, "\n")
-        rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
+        tryCatch(
+            {
+                rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
+                nb_comps <<- nb_comps + 1
+            },
+            error = function(e) {
+                cat("Error compiling ", v, ": ", e$message, "\n")
+                not_compiled <<- c(not_compiled, v)
+            }
+        )
+    } else {
+        cat("Skipping ", v, " (not a closure) but", typeof(f), "\n")
     }
+}
+
+
+cat("Compiled ", nb_comps, " functions out of ", nb_comps + length(not_compiled), "\n")
+if(length(not_compiled) > 0) {
+    cat("The following functions were not compiled: ", paste(not_compiled, collapse = ", "), "\n")
 }
\ No newline at end of file

From a0d2fb2253fbe7e116e7612a3cbd4a2514fcbc80 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 11 Oct 2024 17:56:18 +0200
Subject: [PATCH 73/80] Record the size of messages between the client and the
 server

---
 client/rsh/R/rsh.R                            |  8 ++++++++
 client/rsh/src/client.cpp                     | 20 +++++++++++++++++++
 client/rsh/src/client.hpp                     | 10 ++++++++++
 client/rsh/src/init.cpp                       |  1 +
 .../org/prlprg/server/CompileService.java     |  8 ++++++--
 tools/compile-package.R                       |  9 +++++++--
 6 files changed, 52 insertions(+), 4 deletions(-)

diff --git a/client/rsh/R/rsh.R b/client/rsh/R/rsh.R
index bf691bccf..3d12a3164 100644
--- a/client/rsh/R/rsh.R
+++ b/client/rsh/R/rsh.R
@@ -132,3 +132,11 @@ rsh_override_cmpfun <- function(f) {
   lockBinding("cmpfun", compiler_ns)
 }
 
+#' Get the total size of the messages sent 
+#' and received by the server, in bytes
+#' @return integer vector of size 2, the first element is the total size of requests, 
+#' and the second element is the total size of responses
+#' @export 
+rsh_total_size <- function() {
+  .Call(C_get_total_size)
+}
\ No newline at end of file
diff --git a/client/rsh/src/client.cpp b/client/rsh/src/client.cpp
index 8be9eb553..6225079ef 100644
--- a/client/rsh/src/client.cpp
+++ b/client/rsh/src/client.cpp
@@ -63,15 +63,20 @@ std::variant<protocol::CompileResponse, std::string> Client::remote_compile(std:
   uint64_t hash = xxh::xxhash3<64>(rds_closure.data(), rds_closure.size());
   request.mutable_function()->set_hash(hash);
 
+  total_request_bytes += request.ByteSizeLong();
+  Rprintf("Sending request, with serialized size %ld\n", request.GetCachedSize());
+
   grpc::ClientContext context;
   CompileResponse response;
   grpc::Status status = stub_->Compile(&context, request, &response);
+  total_response_bytes += response.ByteSizeLong();
   if(!status.ok()) {
     std::cerr << status.error_code() << ": " << status.error_message()
               << std::endl;
     return status.error_message();
   }
   else {
+    Rprintf("Received response, with serialized size %ld\n", response.GetCachedSize());
     return response;
   }
 }
@@ -126,4 +131,19 @@ SEXP init_client(SEXP address, SEXP port, SEXP installed_packages) {
   return Client::CLIENT_INSTANCE;
 }
 
+SEXP get_total_size() {
+  auto client = Client::get_client();
+  auto [req, res] = client->get_total_size();
+  SEXP out = PROTECT(Rf_allocVector(INTSXP, 2));
+  INTEGER(out)[0] = req;
+  INTEGER(out)[1] = res;
+  // Add names 
+  SEXP names = PROTECT(Rf_allocVector(STRSXP, 2));
+  SET_STRING_ELT(names, 0, Rf_mkChar("request"));
+  SET_STRING_ELT(names, 1, Rf_mkChar("response"));
+  Rf_setAttrib(out, R_NamesSymbol, names);
+  UNPROTECT(2);
+  return out;
+}
+
 } // namespace rsh
diff --git a/client/rsh/src/client.hpp b/client/rsh/src/client.hpp
index 07f6dd646..026a3effe 100644
--- a/client/rsh/src/client.hpp
+++ b/client/rsh/src/client.hpp
@@ -25,6 +25,9 @@ class Client {
   static inline SEXP RSH_CLIENT_PTR = Rf_install("RSH_CLIENT");
   static void remove_client(SEXP ptr);
 
+  size_t total_request_bytes = 0;
+  size_t total_response_bytes = 0;
+
   // For it to be able to access the client instance
   friend SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
 public:
@@ -34,10 +37,17 @@ class Client {
                                 std::vector<uint8_t> const &rds_closure,
                                 CompilerOptions const &opts);
 
+  // Total size of requests and responses since the start of the client
+  std::pair<size_t , size_t> get_total_size() const {
+    return {total_request_bytes, total_response_bytes};
+  } 
+
   static SEXP make_client(SEXP address, SEXP port, SEXP installed_packages);
   static Client* get_client();
 };
 
+SEXP get_total_size();
+
 SEXP init_client(SEXP address, SEXP port, SEXP installed_packages);
 
 } // namespace rsh
diff --git a/client/rsh/src/init.cpp b/client/rsh/src/init.cpp
index d3981060c..e6d48eb8b 100644
--- a/client/rsh/src/init.cpp
+++ b/client/rsh/src/init.cpp
@@ -13,6 +13,7 @@ static const R_CallMethodDef callMethods[] = {
     {"compile", (DL_FUNC)&rsh::compile, 2},
     {"is_compiled", (DL_FUNC)&rsh::is_compiled, 1},
     {"init_client", (DL_FUNC)&rsh::init_client, 3},
+    {"get_total_size", (DL_FUNC)&rsh::get_total_size, 0},
     {NULL, NULL, 0}};
 
 static const R_ExternalMethodDef externalMethods[] = {
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 5834bf374..c09eb9f8b 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -80,7 +80,9 @@ public void compile(
             + " with bytecode level "
             + (request.hasBcOpt() ? bcOpt : "default 2")
             + " and native optimization level "
-            + (request.hasCcOpt() ? ccOpt : "default 2"));
+            + (request.hasCcOpt() ? ccOpt : "default 2")
+            + " Serialized size = "
+            + request.getSerializedSize());
 
     // Compile the code and build response
     Messages.CompileResponse.Builder response = Messages.CompileResponse.newBuilder();
@@ -201,7 +203,9 @@ public void compile(
     }
 
     // Send the response
-    responseObserver.onNext(response.build());
+    var res = response.build();
+    responseObserver.onNext(res);
+    logger.info("Response size : " + res.getSerializedSize());
     responseObserver.onCompleted();
   }
 
diff --git a/tools/compile-package.R b/tools/compile-package.R
index b172e6819..15b608bd7 100644
--- a/tools/compile-package.R
+++ b/tools/compile-package.R
@@ -35,7 +35,7 @@ for (v in ls(ns)) {
         cat("Compiling ", v, "\n")
         tryCatch(
             {
-                rsh::rsh_compile(f, list(tier = "bytecode", bc_opt = 3L))
+                rsh::rsh_compile(f, list(tier = "native", bc_opt = 3L))
                 nb_comps <<- nb_comps + 1
             },
             error = function(e) {
@@ -52,4 +52,9 @@ for (v in ls(ns)) {
 cat("Compiled ", nb_comps, " functions out of ", nb_comps + length(not_compiled), "\n")
 if(length(not_compiled) > 0) {
     cat("The following functions were not compiled: ", paste(not_compiled, collapse = ", "), "\n")
-}
\ No newline at end of file
+}
+
+message_sizes <- rsh:::rsh_total_size()
+print(message_sizes )
+cat("Cumulated size of requests: ", message_sizes[[1]], "bytes \n")
+cat("Cumulated size of responses: ", message_sizes[[2]], "bytes \n")
\ No newline at end of file

From 6d89afc8a87ca30bd3c9e42fc94c54856e806dc3 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 24 Oct 2024 13:01:40 +0200
Subject: [PATCH 74/80] Collect stats about compiled packages and message sizes

---
 client/rsh/R/rsh.R                            |  1 +
 .../java/org/prlprg/session/GNURSession.java  |  8 +-
 tools/Makefile                                | 16 ++++
 tools/compile-package.R                       | 95 ++++++++++---------
 tools/message-sizes.R                         | 29 ++++++
 5 files changed, 101 insertions(+), 48 deletions(-)
 create mode 100644 tools/Makefile
 create mode 100644 tools/message-sizes.R

diff --git a/client/rsh/R/rsh.R b/client/rsh/R/rsh.R
index 3d12a3164..f22a698ef 100644
--- a/client/rsh/R/rsh.R
+++ b/client/rsh/R/rsh.R
@@ -44,6 +44,7 @@ NULL
 #' @export
 init_client <- function(address="0.0.0.0", port=8980L) {
   .rsh_client <- .Call(C_init_client, address, port, installed.packages()[,1])
+  .rsh_client
 }
 
 #' Activate the Rsh JIT
diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index 2c5c7142b..90042ef52 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -118,10 +118,10 @@ public void loadPackage(String name, String version) {
     DESCRIPTION description = getDescription(name);
 
     String installedVersion = description.getVersion();
-    if (!version.equals(installedVersion)) {
-      throw new RuntimeException(
-          "Version mismatch: expected " + version + " but found " + installedVersion);
-    }
+    //    if (!version.equals(installedVersion)) {
+    //      throw new RuntimeException(
+    //          "Version mismatch: expected " + version + " but found " + installedVersion);
+    //    }
 
     // Use suggests and imports as needed
     var suggests = description.getSuggests();
diff --git a/tools/Makefile b/tools/Makefile
new file mode 100644
index 000000000..4b42fcc92
--- /dev/null
+++ b/tools/Makefile
@@ -0,0 +1,16 @@
+# Saner makefile
+MAKEFLAGS += --no-builtin-rules
+
+LLVM_LIB := $(shell llvm-config-17 --libfiles)
+BEAR := $(shell command -v bear 2> /dev/null)
+
+BASE_DIR = $(realpath $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/..)
+RSH_HOME = $(BASE_DIR)/client/rsh
+R_HOME ?= $(BASE_DIR)/external/R
+R := $(R_HOME)/bin/R --slave --no-restore
+LLVM_R := LD_PRELOAD=$(LLVM_LIB) $(R)
+
+
+.PHONY: package
+package:
+	$(LLVM_R) Rscript compile-package.R tidyr
diff --git a/tools/compile-package.R b/tools/compile-package.R
index 15b608bd7..d5fe8e4b9 100644
--- a/tools/compile-package.R
+++ b/tools/compile-package.R
@@ -6,55 +6,62 @@
 # For yaml
 # LD_PRELOAD=/usr/lib/llvm-17/lib/libLLVM-17.so ../external/R/bin/Rscript compile-package.R yaml
 
-args <- commandArgs(trailingOnly = TRUE)
 
 
-package <- if (length(args) == 0) {
-    stop("At least one argument must be provided")
-} else {
-    args[[1]]
-}
+compile_package <- function(package, tier = "bytecode") {
+    cat(
+        "Compiling package ", package, " at version ",
+        as.character(packageVersion(package)), "\n"
+    )
 
-cat(
-    "Compiling package ", package, " at version ",
-    as.character(packageVersion(package)), "\n"
-)
-
-library(package, character.only = TRUE)
-
-ns <- getNamespace(package)
-
-nb_comps <- 0
-not_compiled <- character(0)    
-
-# Only compile closures
-for (v in ls(ns)) {
-    f <- ns[[v]]
-    if (typeof(f) == "closure") {
-        
-        cat("Compiling ", v, "\n")
-        tryCatch(
-            {
-                rsh::rsh_compile(f, list(tier = "native", bc_opt = 3L))
-                nb_comps <<- nb_comps + 1
-            },
-            error = function(e) {
-                cat("Error compiling ", v, ": ", e$message, "\n")
-                not_compiled <<- c(not_compiled, v)
-            }
-        )
-    } else {
-        cat("Skipping ", v, " (not a closure) but", typeof(f), "\n")
+    library(package, character.only = TRUE)
+
+    ns <- getNamespace(package)
+
+    nb_comps <- 0
+    not_compiled <- character(0)
+
+    # Only compile closures
+    for (v in ls(ns)) {
+        f <- ns[[v]]
+        if (typeof(f) == "closure") {
+            nb_comps <- nb_comps + 1
+            cat("Compiling ", v, "\n")
+            tryCatch(
+                {
+                    rsh::rsh_compile(f, list(tier = tier, bc_opt = 3L))
+                },
+                error = function(e) {
+                    cat("Error compiling ", v, ": ", e$message, "\n")
+                    not_compiled <<- c(not_compiled, v)
+                }
+            )
+        } else {
+            cat("Skipping ", v, " (not a closure) but", typeof(f), "\n")
+        }
     }
-}
 
+    cat("Compiled ", nb_comps, " functions out of ", nb_comps + length(not_compiled), "\n")
+    if (length(not_compiled) > 0) {
+        cat("The following functions were not compiled: ", paste(not_compiled, collapse = ", "), "\n")
+    }
 
-cat("Compiled ", nb_comps, " functions out of ", nb_comps + length(not_compiled), "\n")
-if(length(not_compiled) > 0) {
-    cat("The following functions were not compiled: ", paste(not_compiled, collapse = ", "), "\n")
+    list(sizes = rsh:::rsh_total_size(), nb_comps = nb_comps, nb_fails = length(not_compiled)) # return message sizes
 }
 
-message_sizes <- rsh:::rsh_total_size()
-print(message_sizes )
-cat("Cumulated size of requests: ", message_sizes[[1]], "bytes \n")
-cat("Cumulated size of responses: ", message_sizes[[2]], "bytes \n")
\ No newline at end of file
+
+if (sys.nframe() == 0L) { # Check if we are called from RScript or not
+    args <- commandArgs(trailingOnly = TRUE)
+
+
+    package <- if (length(args) == 0) {
+        stop("At least one argument must be provided")
+    } else {
+        args[[1]]
+    }
+
+    message_sizes <- compile_package(package)
+    print(message_sizes)
+    cat("Cumulated size of requests: ", message_sizes$sizes[[1]], "bytes \n")
+    cat("Cumulated size of responses: ", message_sizes$sizes[[2]], "bytes \n")
+}
diff --git a/tools/message-sizes.R b/tools/message-sizes.R
new file mode 100644
index 000000000..ab5dda85a
--- /dev/null
+++ b/tools/message-sizes.R
@@ -0,0 +1,29 @@
+#! /usr/bin/env Rscript
+
+# LD_PRELOAD=/usr/lib/llvm-17/lib/libLLVM-17.so ../external/R/bin/Rscript messages-sizes.R
+
+
+source("compile-package.R")
+
+packages <- c("yaml", "magrittr", "R6", "glue", "jsonlite", "curl")
+
+results <- list()
+
+rsh::init_client()
+
+for(p in packages) {
+    results[[p]] <- compile_package(p)
+}
+
+# output a csv file
+write.csv(
+    data.frame(
+        package = names(results),
+        request_sizes = sapply(results, function(x) x$sizes[["request"]]),
+        response_sizes = sapply(results, function(x) x$sizes[["response"]]),
+        nb_comps = sapply(results, function(x) x$nb_comps),
+        nb_fails = sapply(results, function(x) x$nb_fails)
+    ),
+    file = "message-sizes.csv",
+    row.names = FALSE
+)
\ No newline at end of file

From 2627f635560516fbfb824e6b4ebba82bd40dc14e Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Tue, 29 Oct 2024 17:55:22 +0100
Subject: [PATCH 75/80] Supports function that has browser inside (do nothing
 and return empty code)

---
 client/rsh/src/compiler.cpp                   |  7 +++++
 .../org/prlprg/server/CompileService.java     | 29 ++++++++++++-------
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 42281f85f..1a930364c 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -200,9 +200,16 @@ SEXP compile(SEXP closure, SEXP options) {
 
   auto compiled_fun = std::get<protocol::CompileResponse>(response);
 
+  // If the code is empty, we keep the SEXP
+  if(!compiled_fun.has_code() || compiled_fun.code().empty()) {
+    Rf_warning("Empty body returned for function %s. Most likely because of browser in the body", opts.name.c_str());
+    return closure;
+  }
+
   SEXP body = nullptr;
   SEXP c_cp = nullptr;
   void * fun_ptr = nullptr;
+
   std::string name = genSymbol(compiled_fun.hash(), 0);
   // Native or bytecode?
   if(opts.tier == protocol::Tier::OPTIMIZED) {
diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index c09eb9f8b..31c379b40 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -9,6 +9,7 @@
 import java.nio.charset.Charset;
 import java.nio.file.Path;
 import java.util.HashMap;
+import java.util.Optional;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import org.prlprg.RVersion;
@@ -133,11 +134,21 @@ public void compile(
                 + ": not found in cache.");
         try {
           var bc = compileBcClosure(function.getBody(), bcOpt);
-          ByteString serializedBc = RDSWriter.writeByteString(SEXPs.bcode(bc));
-          response.setCode(serializedBc);
-          bcCached = Pair.of(bc, serializedBc); // potentially used for the native compilation also
-          // Add it to the cache
-          bcCache.put(bcKey, bcCached);
+          ByteString serializedBc = null;
+          if (bc.isEmpty()) {
+            logger.warning(
+                "Empty bytecode for function "
+                    + function.getName()
+                    + ". Not caching and returning the original body.");
+            // We will keep the code field empty
+          } else {
+            serializedBc = RDSWriter.writeByteString(SEXPs.bcode(bc.get()));
+            response.setCode(serializedBc);
+            bcCached =
+                Pair.of(bc.get(), serializedBc); // potentially used for the native compilation also
+            // Add it to the cache
+            bcCache.put(bcKey, bcCached);
+          }
         } catch (Exception e) {
           // See
           // https://github.com/grpc/grpc-java/blob/master/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
@@ -247,7 +258,7 @@ private RVersion convertVersion(Messages.Version version) {
     return new RVersion(version.getMajor(), version.getMinor(), version.getPatch());
   }
 
-  private Bc compileBcClosure(ByteString body, int optimizationLevel) {
+  private Optional<Bc> compileBcClosure(ByteString body, int optimizationLevel) {
     SEXP closure = null;
     try {
       assert session != null;
@@ -258,11 +269,7 @@ private Bc compileBcClosure(ByteString body, int optimizationLevel) {
     if (closure instanceof CloSXP c) {
       BCCompiler compiler = new BCCompiler(c, session);
       compiler.setOptimizationLevel(optimizationLevel);
-      var bc = compiler.compile();
-      if (bc.isEmpty()) {
-        throw new RuntimeException("Bytecode compilation failed");
-      }
-      return bc.get();
+      return compiler.compile();
     } else {
       throw new RuntimeException("Not a closure");
     }

From fbb613771a3e72caefcc3aca4ad0a104f549111a Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Wed, 30 Oct 2024 16:19:19 +0100
Subject: [PATCH 76/80] Adding compression to server responses

---
 .../src/main/java/org/prlprg/server/CompileService.java  | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/server/src/main/java/org/prlprg/server/CompileService.java b/server/src/main/java/org/prlprg/server/CompileService.java
index 31c379b40..7709e12a7 100644
--- a/server/src/main/java/org/prlprg/server/CompileService.java
+++ b/server/src/main/java/org/prlprg/server/CompileService.java
@@ -3,6 +3,7 @@
 import com.google.common.io.Files;
 import com.google.protobuf.ByteString;
 import io.grpc.Status;
+import io.grpc.stub.ServerCallStreamObserver;
 import io.grpc.stub.StreamObserver;
 import java.io.File;
 import java.io.IOException;
@@ -54,7 +55,13 @@ private static String genSymbol(Messages.Function function) {
   // CompileService.Compile
   @Override
   public void compile(
-      Messages.CompileRequest request, StreamObserver<Messages.CompileResponse> responseObserver) {
+      Messages.CompileRequest request,
+      StreamObserver<Messages.CompileResponse> plainResponseObserver) {
+
+    ServerCallStreamObserver<Messages.CompileResponse> responseObserver =
+        (ServerCallStreamObserver<Messages.CompileResponse>) plainResponseObserver;
+    responseObserver.setCompression(
+        "gzip"); // Or for all responses? In that case, we just need to add an interceptor.
 
     if (session == null) {
       responseObserver.onError(

From 15946d8b99c9a3ec2bc9042dc649d88681027616 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Fri, 8 Nov 2024 15:15:28 +0100
Subject: [PATCH 77/80] Make BC2C tests pass again

---
 .../org/prlprg/bc2c/BC2CCompilerTest.java     | 39 ++++++++++---------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java b/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
index 5d75781fd..b4e857759 100644
--- a/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
+++ b/server/src/test/java/org/prlprg/bc2c/BC2CCompilerTest.java
@@ -428,13 +428,14 @@ public void testNestedFor(BC2CSnapshot snapshot) {
     // this for loop will not use ISQ as it will be constant folded
     snapshot.verify(
         """
-                        s <- 0L
-                        for (i in 1:10) {
-    for (j in 1:10) {
-      s <- s + j + i
-    }
-  }s
-                        """,
+  s <- 0L
+  for (i in 1:10) {
+      for (j in 1:10) {
+          s <- s + j + i
+      }
+  }
+  s
+  """,
         returns(1100));
   }
 
@@ -443,8 +444,8 @@ public void testColon(BC2CSnapshot snapshot) {
     snapshot.verify(
         """
     x <- 1
-      y <- 10
-        x:y
+    y <- 10
+    x:y
       """,
         x -> assertEquals(x.pc().isq(), 1));
   }
@@ -519,19 +520,19 @@ public void testIf(BC2CSnapshot snapshot) {
             x <- 10
             if (x > 0) {
               3
-    }
-  x
+            }
+            x
             """);
     snapshot.verify(
         """
-            function(x) {
-              if (x > 0) {
-              }
-              1
-            }
-
-  1
-    """);
+      function(x) {
+        if (x > 0) {
+        }
+        1
+      }
+
+      1
+      """);
   }
 
   private TestResultCheck fastArith() {

From 6d64c9400f22c868389631530fb53aa3dc2e2656 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 21 Nov 2024 12:29:08 +0100
Subject: [PATCH 78/80] Client now compiles again

---
 client/rsh/src/compiler.cpp | 62 ++-----------------------------------
 1 file changed, 3 insertions(+), 59 deletions(-)

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 57832b2f2..937758b00 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -66,63 +66,6 @@ static void *insert_into_jit(const char* name, protocol::CompileResponse const &
   return ptr;
 }
 
-static SEXP create_constant_pool(void *fun_ptr, const char* name,
-                                 protocol::CompileResponse const &compiled_fun) {
-  auto pool = PROTECT(Rf_allocVector(VECSXP, 2));
-
-  // create an external pointer to the JITed function with a finalizer
-  auto p = R_MakeExternalPtr(fun_ptr, RSH_JIT_FUN_PTR,
-                             Rf_mkString(name));
-  R_RegisterCFinalizerEx(p, &jit_fun_destructor, FALSE);
-
-  // slot 0: the pointer to the compiled function
-  SET_VECTOR_ELT(pool, 0, p);
-
-  // slot 1: the contants used by the compiled function
-  auto consts_vec = rsh::deserialize(compiled_fun.constants());
-  SET_VECTOR_ELT(pool, 1, consts_vec);
-
-  UNPROTECT(1); // consts
-
-  return pool;
-}
-
-static SEXP create_wrapper_body(SEXP closure, SEXP c_cp) {
-  auto bc_size = sizeof(CALL_FUN_BC) / sizeof(i32);
-
-  auto bc = PROTECT(Rf_allocVector(INTSXP, bc_size));
-  memcpy(INTEGER(bc), CALL_FUN_BC, sizeof(CALL_FUN_BC));
-  bc = R_bcEncode(bc);
-
-  auto expr_index = PROTECT(Rf_allocVector(INTSXP, bc_size));
-  INTEGER(expr_index)[0] = NA_INTEGER;
-  memset(INTEGER(expr_index) + 1, 0, (bc_size - 1) * sizeof(i32));
-
-  auto cp = PROTECT(Rf_allocVector(VECSXP, 6));
-  int i = 0;
-
-  // store the original AST (consequently it will not correspond to the AST)
-  SET_VECTOR_ELT(cp, i++, BODY(closure));
-  SET_VECTOR_ELT(cp, i++, Rf_install(".External2"));
-  SET_VECTOR_ELT(cp, i++, BC2C_CALL_TRAMPOLINE_SXP);
-  SET_VECTOR_ELT(cp, i++, closure);
-  SET_VECTOR_ELT(cp, i++, c_cp);
-  SET_VECTOR_ELT(cp, i++, expr_index);
-
-  // properly name the expression index (the last element of the constant pool)
-  auto cp_names = Rf_allocVector(STRSXP, 6);
-  Rf_setAttrib(cp, R_NamesSymbol, cp_names);
-  for (i = 0; i < 5; i++) {
-    SET_STRING_ELT(cp_names, i, R_BlankString);
-  }
-  SET_STRING_ELT(cp_names, 5, Rf_mkChar("expressionIndex"));
-
-  auto body = Rf_cons(bc, cp);
-  SET_TYPEOF(body, BCODESXP);
-
-  UNPROTECT(3);
-  return body;
-}
 
 CompilerOptions CompilerOptions::from_list(SEXP listsxp) {
   if (TYPEOF(listsxp) != VECSXP) {
@@ -208,14 +151,15 @@ SEXP compile(SEXP closure, SEXP options) {
 
   SEXP body = nullptr;
   SEXP c_cp = nullptr;
-  void * fun_ptr = nullptr;
+  void* fun_ptr;
+  SEXP fun_ptr_sxp = nullptr;
 
   std::string name = genSymbol(compiled_fun.hash(), 0);
   // Native or bytecode?
   if(opts.tier == protocol::Tier::OPTIMIZED) {
     fun_ptr = insert_into_jit(name.c_str(), compiled_fun);
     auto fun_ptr_sxp = R_MakeExternalPtr(
-          fun_ptr, RSH_JIT_FUN_PTR, Rf_mkString(compiled_fun.name().c_str()));
+          fun_ptr, RSH_JIT_FUN_PTR, Rf_mkString(name.c_str()));
       R_RegisterCFinalizerEx(fun_ptr_sxp, &jit_fun_destructor, FALSE);
 
     auto c_cp = rsh::deserialize(compiled_fun.constants());

From b2835a07a657992cb57deccf97777c6541c14e45 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 21 Nov 2024 13:18:48 +0100
Subject: [PATCH 79/80] Fix creation of closure for optimized code: correctly
 build the body before

---
 client/rsh/src/compiler.cpp | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

diff --git a/client/rsh/src/compiler.cpp b/client/rsh/src/compiler.cpp
index 937758b00..50f34f173 100644
--- a/client/rsh/src/compiler.cpp
+++ b/client/rsh/src/compiler.cpp
@@ -151,7 +151,7 @@ SEXP compile(SEXP closure, SEXP options) {
 
   SEXP body = nullptr;
   SEXP c_cp = nullptr;
-  void* fun_ptr;
+  void* fun_ptr = nullptr;
   SEXP fun_ptr_sxp = nullptr;
 
   std::string name = genSymbol(compiled_fun.hash(), 0);
@@ -163,10 +163,10 @@ SEXP compile(SEXP closure, SEXP options) {
       R_RegisterCFinalizerEx(fun_ptr_sxp, &jit_fun_destructor, FALSE);
 
     auto c_cp = rsh::deserialize(compiled_fun.constants());
-
+    body = PROTECT(create_wrapper_body(closure, fun_ptr_sxp, c_cp));//P1
   }
   else if(opts.tier == protocol::Tier::BASELINE) {
-    body = PROTECT(rsh::deserialize(compiled_fun.code()));
+    body = PROTECT(rsh::deserialize(compiled_fun.code())); // P2
     if(TYPEOF(body) != BCODESXP) {
       Rf_error("Expected bytecode, got %s", Rf_type2char(TYPEOF(body)));
     }
@@ -174,11 +174,8 @@ SEXP compile(SEXP closure, SEXP options) {
 
   // Inplace or not (i.e. through through an explicit call to `compile` or through the R JIT)
   if (opts.inplace) {
-    if(opts.tier == protocol::Tier::OPTIMIZED) {
-       body = PROTECT(create_wrapper_body(closure, fun_ptr_sxp, c_cp));
-    }
     SET_BODY(closure, body);
-    UNPROTECT(1);
+    UNPROTECT(1); // For P1 or P2
     // FIXME: add logging primitives
     Rprintf("Compiled in place fun %s (fun=%p, body=%p) ; ",
             opts.name.c_str(), closure,
@@ -191,9 +188,9 @@ SEXP compile(SEXP closure, SEXP options) {
     }
   } else {
     SEXP orig = closure;
-    closure = PROTECT(Rf_mkCLOSXP(FORMALS(closure), body, CLOENV(closure)));
+    closure = PROTECT(Rf_mkCLOSXP(FORMALS(closure), body, CLOENV(closure))); // P3
     // FIXME: add logging primitive
-    UNPROTECT(1);
+    UNPROTECT(1);// P1 or P2
     Rprintf(
         "Replaced compiled fun %s -- %p (fun=%p, body=%p) ; ",
         opts.name.c_str(), orig, closure,
@@ -206,14 +203,7 @@ SEXP compile(SEXP closure, SEXP options) {
     }
   }
 
-  // Unprotecting after creating the bodies above.
-  if(opts.tier == protocol::Tier::OPTIMIZED) {
-    UNPROTECT(2);
-  }
-  else {
-    UNPROTECT(1);
-  }
-
+  UNPROTECT(1); // P3
 
   return closure;
 }

From c9e2d3aa120df9f006895a4a89f289486202b799 Mon Sep 17 00:00:00 2001
From: Pierre Donat-Bouillud <pierre.donat.bouillud@gmail.com>
Date: Thu, 21 Nov 2024 13:24:16 +0100
Subject: [PATCH 80/80] Reinstate the exception when there is a version
 mismatch in installed vs required R packages when compiling

---
 .../src/main/java/org/prlprg/session/GNURSession.java  | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/server/src/main/java/org/prlprg/session/GNURSession.java b/server/src/main/java/org/prlprg/session/GNURSession.java
index 90042ef52..4989e80da 100644
--- a/server/src/main/java/org/prlprg/session/GNURSession.java
+++ b/server/src/main/java/org/prlprg/session/GNURSession.java
@@ -118,10 +118,12 @@ public void loadPackage(String name, String version) {
     DESCRIPTION description = getDescription(name);
 
     String installedVersion = description.getVersion();
-    //    if (!version.equals(installedVersion)) {
-    //      throw new RuntimeException(
-    //          "Version mismatch: expected " + version + " but found " + installedVersion);
-    //    }
+
+    // TODO: Handle that better that throwing an error.
+    if (!version.equals(installedVersion)) {
+      throw new RuntimeException(
+          "Version mismatch: expected " + version + " but found " + installedVersion);
+    }
 
     // Use suggests and imports as needed
     var suggests = description.getSuggests();