for (const auto* edge : oper->node.out_edges()) {
    if (edge->IsControlEdge() && !edge->dst()->IsSink()) {
      ++count;
    }
  }
  return count;
}

int TF_OperationGetControlOutputs(TF_Operation* oper,
                                  TF_Operation** control_outputs,
                                  int max_control_outputs) {
  int count = 0;
  for (const auto* edge : oper->node.out_edges()) {

        final int length = string.length();
        if (length == 0) {
            return new byte[0];
        }
        final int pad = string.charAt(length - 2) == '=' ? 2 : string.charAt(length - 1) == '=' ? 1 : 0;
        final int size = length * 3 / 4 - pad;
        final byte[] buffer = new byte[size];
        int block;
        int i = 0;
        int index = 0;
        while (i < length) {

    }
  }

  private interface Adder {
    int add(int a, int b);
  }

  private static final class ForwardingArithmetic implements Arithmetic {
    private final Arithmetic arithmetic;

    ForwardingArithmetic(Arithmetic arithmetic) {
      this.arithmetic = arithmetic;
    }

    @Override
    public int add(int a, int b) {
      return arithmetic.add(a, b);
    }

    @Override

  override fun getLocalPort(): Int = delegate!!.localPort

  @Throws(IOException::class)
  override fun getOutputStream(): OutputStream = delegate!!.outputStream

  override fun getPort(): Int = delegate!!.port

  @Throws(SocketException::class)
  override fun getSoLinger(): Int = delegate!!.soLinger

  @Throws(SocketException::class)

   *     such index exists.
   */
  public static int indexOf(short[] array, short target) {
    return indexOf(array, target, 0, array.length);
  }

  // TODO(kevinb): consider making this public
  private static int indexOf(short[] array, short target, int start, int end) {
    for (int i = start; i < end; i++) {
      if (array[i] == target) {
        return i;
      }
    }

    public void rdmaRead(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException {
        // TCP fallback doesn't support real RDMA read
        throw new UnsupportedOperationException("RDMA read not supported by TCP fallback");
    }

    @Override
    public void rdmaWrite(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException {

        return 6;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override

            }
        }
        return buf;
    }

    private static int carry_add(byte[] data, byte[] out, int c, int i) {
        int ilen = data.length, olen = out.length;
        int msbit = ((ilen << 3) - 1 + ((ilen << 3) + 13) * (i / ilen) + (ilen - i % ilen << 3)) % (ilen << 3);
        int mshigh = msbit >>> 3, mslow = msbit & 7;
        int b = c + (out[i % olen] & 0xff)

    }

    @Override
    int writeBodyWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readBodyWireFormat(final byte[] src, final int srcIndex) {
        return readResourceRecordWireFormat(src, srcIndex);
    }

    @Override
    int writeRDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

      return forwardList;
    }

    private int reverseIndex(int index) {
      int size = size();
      checkElementIndex(index, size);
      return (size - 1) - index;
    }

    private int reversePosition(int index) {
      int size = size();
      checkPositionIndex(index, size);
      return size - index;
    }

    @Override
    public void add(int index, @ParametricNullness T element) {