public static int CreateListThreadsResponse(FlatBufferBuilder builder,
 int thread = 0)
   {
       builder.StartObject(1);
       ListThreadsResponse.AddThread(builder, thread);
       return ListThreadsResponse.EndListThreadsResponse(builder);
   }

 public static Offset<Test> CreateTest(FlatBufferBuilder builder, short A, sbyte B) {
   builder.Prep(2, 4);
   builder.Pad(1);
   builder.PutSbyte(B);
   builder.PutShort(A);
   return new Offset<Test>(builder.Offset);
 }

 public static int CreateListModuleEntry(FlatBufferBuilder builder, uint Handle, uint FunctionCount)
 {
     builder.Prep(4, 8);
     builder.PutUint(FunctionCount);
     builder.PutUint(Handle);
     return builder.Offset;
 }

 public static Offset<Area> CreateArea(FlatBufferBuilder builder, float Largura, float Comprimento)
 {
     builder.Prep(4, 8);
     builder.PutFloat(Comprimento);
     builder.PutFloat(Largura);
     return new Offset<Area>(builder.Offset);
 }

    void RunSerialize()
    {
        for (int i = 0; i < N; i++)
        {
            FlatBufferBuilder messageBuffer = new FlatBufferBuilder(100);

            var text = messageBuffer.CreateString(@"Test message included");

            int embeddedOffset = EmbeddedMessage.CreateEmbeddedMessage(messageBuffer, i);

            TestMessage.StartTestMessage(messageBuffer);
            TestMessage.AddText(messageBuffer, text.Value);
            TestMessage.AddEmbedded(messageBuffer, embeddedOffset);
            TestMessage.AddId(messageBuffer, i);
            int testMessage = TestMessage.EndTestMessage(messageBuffer);
            TestMessage.FinishTestMessageBuffer(messageBuffer, testMessage);

            string s = "";
            for (int j = 0; j < messageBuffer.DataBuffer.Data.Length; j++) s += messageBuffer.DataBuffer.Data[i].ToString() + ", ";
            Debug.Log(s);

            using (MemoryStream ms = new MemoryStream(messageBuffer.DataBuffer.Data,
                                                      0,
                                                      messageBuffer.DataBuffer.Data.Length))
            {
                ByteBuffer byteBuffer = new ByteBuffer(ms.ToArray());
                TestMessage parsed = TestMessage.GetRootAsTestMessage(byteBuffer);

                if (parsed.Embedded().Id() != i) throw new Exception("Invalid embedded value");
            }
        }
    }

 public static Offset<SecondTableInA> CreateSecondTableInA(FlatBufferBuilder builder,
     Offset<NamespaceC.TableInC> refer_to_cOffset = default(Offset<NamespaceC.TableInC>))
 {
     builder.StartObject(1);
     SecondTableInA.AddReferToC(builder, refer_to_cOffset);
     return SecondTableInA.EndSecondTableInA(builder);
 }

 public static int CreateTest(FlatBufferBuilder builder, short A, sbyte B) {
   builder.Prep(2, 4);
   builder.Pad(1);
   builder.PutSbyte(B);
   builder.PutShort(A);
   return builder.Offset();
 }

   public static int CreateGetFunctionResponse(FlatBufferBuilder builder,
 int function = 0)
   {
       builder.StartObject(1);
       GetFunctionResponse.AddFunction(builder, function);
       return GetFunctionResponse.EndGetFunctionResponse(builder);
   }

   public static Offset<VariableParameters> CreateVariableParameters(FlatBufferBuilder builder,
 VariableType type = (VariableType)0)
   {
       builder.StartObject(1);
       VariableParameters.AddType(builder, type);
       return VariableParameters.EndVariableParameters(builder);
   }

   public static int CreateAddBreakpointsRequest(FlatBufferBuilder builder,
 int breakpoints = 0)
   {
       builder.StartObject(1);
       AddBreakpointsRequest.AddBreakpoints(builder, breakpoints);
       return AddBreakpointsRequest.EndAddBreakpointsRequest(builder);
   }

   public static Offset<LoginRequest> CreateLoginRequest(FlatBufferBuilder builder,
 StringOffset name = default(StringOffset))
   {
       builder.StartObject(1);
       LoginRequest.AddName(builder, name);
       return LoginRequest.EndLoginRequest(builder);
   }

   public static Offset<anchorPointsHolder> CreateanchorPointsHolder(FlatBufferBuilder builder,
 VectorOffset anchorPoints = default(VectorOffset))
   {
       builder.StartObject(1);
       anchorPointsHolder.AddAnchorPoints(builder, anchorPoints);
       return anchorPointsHolder.EndanchorPointsHolder(builder);
   }

   public static Offset<LoginResponse> CreateLoginResponse(FlatBufferBuilder builder,
 int objectId = 0)
   {
       builder.StartObject(1);
       LoginResponse.AddObjectId(builder, objectId);
       return LoginResponse.EndLoginResponse(builder);
   }

   public static Offset<InputCommand> CreateInputCommand(FlatBufferBuilder builder,
 Offset<CommandFrame> frame = default(Offset<CommandFrame>))
   {
       builder.StartObject(1);
       InputCommand.AddFrame(builder, frame);
       return InputCommand.EndInputCommand(builder);
   }

   public static int CreateGetModuleRequest(FlatBufferBuilder builder,
 uint module_id = 0)
   {
       builder.StartObject(1);
       GetModuleRequest.AddModuleId(builder, module_id);
       return GetModuleRequest.EndGetModuleRequest(builder);
   }

   public static Offset<animation> Createanimation(FlatBufferBuilder builder,
 VectorOffset clips = default(VectorOffset))
   {
       builder.StartObject(1);
       animation.AddClips(builder, clips);
       return animation.Endanimation(builder);
   }

 public static Offset<StructInNestedNS> CreateStructInNestedNS(FlatBufferBuilder builder, int A, int B)
 {
     builder.Prep(4, 8);
     builder.PutInt(B);
     builder.PutInt(A);
     return new Offset<StructInNestedNS>(builder.Offset);
 }

   public static int CreateListModulesResponse(FlatBufferBuilder builder,
 int entry = 0)
   {
       builder.StartObject(1);
       ListModulesResponse.AddEntry(builder, entry);
       return ListModulesResponse.EndListModulesResponse(builder);
   }

   public static Offset<skeleton> Createskeleton(FlatBufferBuilder builder,
 VectorOffset bones = default(VectorOffset))
   {
       builder.StartObject(1);
       skeleton.AddBones(builder, bones);
       return skeleton.Endskeleton(builder);
   }

   public static Offset<TableInNestedNS> CreateTableInNestedNS(FlatBufferBuilder builder,
 int foo = 0)
   {
       builder.StartObject(1);
       TableInNestedNS.AddFoo(builder, foo);
       return TableInNestedNS.EndTableInNestedNS(builder);
   }