diff --git a/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.cs b/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.cs
index ff44023..bb17d7b 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.cs
+++ b/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.cs
@@ -5,6 +5,7 @@
 namespace NamespaceA.NamespaceB
 {
 
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
 public enum EnumInNestedNS : sbyte
 {
   A = 0,
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.cs b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.cs
index 9aba8db..6fa9dd3 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.cs
+++ b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.cs
@@ -6,6 +6,7 @@
 {
 
 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;
 
 public struct StructInNestedNS : IFlatbufferObject
@@ -26,7 +27,36 @@
     builder.PutInt(A);
     return new Offset<NamespaceA.NamespaceB.StructInNestedNS>(builder.Offset);
   }
+  public StructInNestedNST UnPack() {
+    var _o = new StructInNestedNST();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(StructInNestedNST _o) {
+    _o.A = this.A;
+    _o.B = this.B;
+  }
+  public static Offset<NamespaceA.NamespaceB.StructInNestedNS> Pack(FlatBufferBuilder builder, StructInNestedNST _o) {
+    if (_o == null) return default(Offset<NamespaceA.NamespaceB.StructInNestedNS>);
+    return CreateStructInNestedNS(
+      builder,
+      _o.A,
+      _o.B);
+  }
 };
 
+public class StructInNestedNST
+{
+  [Newtonsoft.Json.JsonProperty("a")]
+  public int A { get; set; }
+  [Newtonsoft.Json.JsonProperty("b")]
+  public int B { get; set; }
+
+  public StructInNestedNST() {
+    this.A = 0;
+    this.B = 0;
+  }
+}
+
 
 }
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.go b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.go
index e985fbf..854403f 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.go
+++ b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.go
@@ -6,6 +6,27 @@
 	flatbuffers "github.com/google/flatbuffers/go"
 )
 
+type StructInNestedNST struct {
+	A int32
+	B int32
+}
+
+func (t *StructInNestedNST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	if t == nil { return 0 }
+	return CreateStructInNestedNS(builder, t.A, t.B)
+}
+func (rcv *StructInNestedNS) UnPackTo(t *StructInNestedNST) {
+	t.A = rcv.A()
+	t.B = rcv.B()
+}
+
+func (rcv *StructInNestedNS) UnPack() *StructInNestedNST {
+	if rcv == nil { return nil }
+	t := &StructInNestedNST{}
+	rcv.UnPackTo(t)
+	return t
+}
+
 type StructInNestedNS struct {
 	_tab flatbuffers.Struct
 }
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.java b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.java
index 284f89a..6505561 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.java
+++ b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.java
@@ -23,5 +23,12 @@
     builder.putInt(a);
     return builder.offset();
   }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public StructInNestedNS get(int j) { return get(new StructInNestedNS(), j); }
+    public StructInNestedNS get(StructInNestedNS obj, int j) {  return obj.__assign(__element(j), bb); }
+  }
 }
 
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.py b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.py
index 59cceaa..f49495b 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.py
+++ b/tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.py
@@ -3,10 +3,16 @@
 # namespace: NamespaceB
 
 import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
 
 class StructInNestedNS(object):
     __slots__ = ['_tab']
 
+    @classmethod
+    def SizeOf(cls):
+        return 8
+
     # StructInNestedNS
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
@@ -21,3 +27,34 @@
     builder.PrependInt32(b)
     builder.PrependInt32(a)
     return builder.Offset()
+
+
+class StructInNestedNST(object):
+
+    # StructInNestedNST
+    def __init__(self):
+        self.a = 0  # type: int
+        self.b = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        structInNestedNS = StructInNestedNS()
+        structInNestedNS.Init(buf, pos)
+        return cls.InitFromObj(structInNestedNS)
+
+    @classmethod
+    def InitFromObj(cls, structInNestedNS):
+        x = StructInNestedNST()
+        x._UnPack(structInNestedNS)
+        return x
+
+    # StructInNestedNST
+    def _UnPack(self, structInNestedNS):
+        if structInNestedNS is None:
+            return
+        self.a = structInNestedNS.A()
+        self.b = structInNestedNS.B()
+
+    # StructInNestedNST
+    def Pack(self, builder):
+        return CreateStructInNestedNS(builder, self.a, self.b)
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs
index f8ea32b..cdbf6f8 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs
+++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs
@@ -6,13 +6,14 @@
 {
 
 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;
 
 public struct TableInNestedNS : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
   public static TableInNestedNS GetRootAsTableInNestedNS(ByteBuffer _bb) { return GetRootAsTableInNestedNS(_bb, new TableInNestedNS()); }
   public static TableInNestedNS GetRootAsTableInNestedNS(ByteBuffer _bb, TableInNestedNS obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -34,7 +35,31 @@
     int o = builder.EndTable();
     return new Offset<NamespaceA.NamespaceB.TableInNestedNS>(o);
   }
+  public TableInNestedNST UnPack() {
+    var _o = new TableInNestedNST();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(TableInNestedNST _o) {
+    _o.Foo = this.Foo;
+  }
+  public static Offset<NamespaceA.NamespaceB.TableInNestedNS> Pack(FlatBufferBuilder builder, TableInNestedNST _o) {
+    if (_o == null) return default(Offset<NamespaceA.NamespaceB.TableInNestedNS>);
+    return CreateTableInNestedNS(
+      builder,
+      _o.Foo);
+  }
 };
 
+public class TableInNestedNST
+{
+  [Newtonsoft.Json.JsonProperty("foo")]
+  public int Foo { get; set; }
+
+  public TableInNestedNST() {
+    this.Foo = 0;
+  }
+}
+
 
 }
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.go b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.go
index 75f7a55..3782645 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.go
+++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.go
@@ -6,6 +6,28 @@
 	flatbuffers "github.com/google/flatbuffers/go"
 )
 
+type TableInNestedNST struct {
+	Foo int32
+}
+
+func (t *TableInNestedNST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	if t == nil { return 0 }
+	TableInNestedNSStart(builder)
+	TableInNestedNSAddFoo(builder, t.Foo)
+	return TableInNestedNSEnd(builder)
+}
+
+func (rcv *TableInNestedNS) UnPackTo(t *TableInNestedNST) {
+	t.Foo = rcv.Foo()
+}
+
+func (rcv *TableInNestedNS) UnPack() *TableInNestedNST {
+	if rcv == nil { return nil }
+	t := &TableInNestedNST{}
+	rcv.UnPackTo(t)
+	return t
+}
+
 type TableInNestedNS struct {
 	_tab flatbuffers.Table
 }
@@ -17,6 +39,13 @@
 	return x
 }
 
+func GetSizePrefixedRootAsTableInNestedNS(buf []byte, offset flatbuffers.UOffsetT) *TableInNestedNS {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &TableInNestedNS{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
 func (rcv *TableInNestedNS) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.java b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.java
index af1449b..b0931b1 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.java
+++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.java
@@ -9,7 +9,7 @@
 
 @SuppressWarnings("unused")
 public final class TableInNestedNS extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
   public static TableInNestedNS getRootAsTableInNestedNS(ByteBuffer _bb) { return getRootAsTableInNestedNS(_bb, new TableInNestedNS()); }
   public static TableInNestedNS getRootAsTableInNestedNS(ByteBuffer _bb, TableInNestedNS obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -31,5 +31,12 @@
     int o = builder.endTable();
     return o;
   }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public TableInNestedNS get(int j) { return get(new TableInNestedNS(), j); }
+    public TableInNestedNS get(TableInNestedNS obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
 }
 
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.kt b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.kt
index 59ebdc9..0fb2e3c 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.kt
+++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.kt
@@ -32,7 +32,7 @@
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+        fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
         fun getRootAsTableInNestedNS(_bb: ByteBuffer): TableInNestedNS = getRootAsTableInNestedNS(_bb, TableInNestedNS())
         fun getRootAsTableInNestedNS(_bb: ByteBuffer, obj: TableInNestedNS): TableInNestedNS {
             _bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py
index d6d1674..e86ba63 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py
+++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py
@@ -3,6 +3,8 @@
 # namespace: NamespaceB
 
 import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
 
 class TableInNestedNS(object):
     __slots__ = ['_tab']
@@ -28,3 +30,35 @@
 def TableInNestedNSStart(builder): builder.StartObject(1)
 def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
 def TableInNestedNSEnd(builder): return builder.EndObject()
+
+
+class TableInNestedNST(object):
+
+    # TableInNestedNST
+    def __init__(self):
+        self.foo = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        tableInNestedNS = TableInNestedNS()
+        tableInNestedNS.Init(buf, pos)
+        return cls.InitFromObj(tableInNestedNS)
+
+    @classmethod
+    def InitFromObj(cls, tableInNestedNS):
+        x = TableInNestedNST()
+        x._UnPack(tableInNestedNS)
+        return x
+
+    # TableInNestedNST
+    def _UnPack(self, tableInNestedNS):
+        if tableInNestedNS is None:
+            return
+        self.foo = tableInNestedNS.Foo()
+
+    # TableInNestedNST
+    def Pack(self, builder):
+        TableInNestedNSStart(builder)
+        TableInNestedNSAddFoo(builder, self.foo)
+        tableInNestedNS = TableInNestedNSEnd(builder)
+        return tableInNestedNS
diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.cs b/tests/namespace_test/NamespaceA/SecondTableInA.cs
index 7e08de8..a949c61 100644
--- a/tests/namespace_test/NamespaceA/SecondTableInA.cs
+++ b/tests/namespace_test/NamespaceA/SecondTableInA.cs
@@ -6,13 +6,14 @@
 {
 
 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;
 
 public struct SecondTableInA : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
   public static SecondTableInA GetRootAsSecondTableInA(ByteBuffer _bb) { return GetRootAsSecondTableInA(_bb, new SecondTableInA()); }
   public static SecondTableInA GetRootAsSecondTableInA(ByteBuffer _bb, SecondTableInA obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -33,7 +34,32 @@
     int o = builder.EndTable();
     return new Offset<NamespaceA.SecondTableInA>(o);
   }
+  public SecondTableInAT UnPack() {
+    var _o = new SecondTableInAT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(SecondTableInAT _o) {
+    _o.ReferToC = this.ReferToC.HasValue ? this.ReferToC.Value.UnPack() : null;
+  }
+  public static Offset<NamespaceA.SecondTableInA> Pack(FlatBufferBuilder builder, SecondTableInAT _o) {
+    if (_o == null) return default(Offset<NamespaceA.SecondTableInA>);
+    var _refer_to_c = _o.ReferToC == null ? default(Offset<NamespaceC.TableInC>) : NamespaceC.TableInC.Pack(builder, _o.ReferToC);
+    return CreateSecondTableInA(
+      builder,
+      _refer_to_c);
+  }
 };
 
+public class SecondTableInAT
+{
+  [Newtonsoft.Json.JsonProperty("refer_to_c")]
+  public NamespaceC.TableInCT ReferToC { get; set; }
+
+  public SecondTableInAT() {
+    this.ReferToC = null;
+  }
+}
+
 
 }
diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.go b/tests/namespace_test/NamespaceA/SecondTableInA.go
index 6dd1eef..f88a682 100644
--- a/tests/namespace_test/NamespaceA/SecondTableInA.go
+++ b/tests/namespace_test/NamespaceA/SecondTableInA.go
@@ -8,6 +8,29 @@
 	NamespaceC "NamespaceC"
 )
 
+type SecondTableInAT struct {
+	ReferToC *NamespaceC.TableInCT
+}
+
+func (t *SecondTableInAT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	if t == nil { return 0 }
+	referToCOffset := t.ReferToC.Pack(builder)
+	SecondTableInAStart(builder)
+	SecondTableInAAddReferToC(builder, referToCOffset)
+	return SecondTableInAEnd(builder)
+}
+
+func (rcv *SecondTableInA) UnPackTo(t *SecondTableInAT) {
+	t.ReferToC = rcv.ReferToC(nil).UnPack()
+}
+
+func (rcv *SecondTableInA) UnPack() *SecondTableInAT {
+	if rcv == nil { return nil }
+	t := &SecondTableInAT{}
+	rcv.UnPackTo(t)
+	return t
+}
+
 type SecondTableInA struct {
 	_tab flatbuffers.Table
 }
@@ -19,6 +42,13 @@
 	return x
 }
 
+func GetSizePrefixedRootAsSecondTableInA(buf []byte, offset flatbuffers.UOffsetT) *SecondTableInA {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &SecondTableInA{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
 func (rcv *SecondTableInA) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i
diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.java b/tests/namespace_test/NamespaceA/SecondTableInA.java
index a655199..ec6e561 100644
--- a/tests/namespace_test/NamespaceA/SecondTableInA.java
+++ b/tests/namespace_test/NamespaceA/SecondTableInA.java
@@ -9,7 +9,7 @@
 
 @SuppressWarnings("unused")
 public final class SecondTableInA extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
   public static SecondTableInA getRootAsSecondTableInA(ByteBuffer _bb) { return getRootAsSecondTableInA(_bb, new SecondTableInA()); }
   public static SecondTableInA getRootAsSecondTableInA(ByteBuffer _bb, SecondTableInA obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -31,5 +31,12 @@
     int o = builder.endTable();
     return o;
   }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public SecondTableInA get(int j) { return get(new SecondTableInA(), j); }
+    public SecondTableInA get(SecondTableInA obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
 }
 
diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.kt b/tests/namespace_test/NamespaceA/SecondTableInA.kt
index 8261443..5b41f73 100644
--- a/tests/namespace_test/NamespaceA/SecondTableInA.kt
+++ b/tests/namespace_test/NamespaceA/SecondTableInA.kt
@@ -27,7 +27,7 @@
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+        fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
         fun getRootAsSecondTableInA(_bb: ByteBuffer): SecondTableInA = getRootAsSecondTableInA(_bb, SecondTableInA())
         fun getRootAsSecondTableInA(_bb: ByteBuffer, obj: SecondTableInA): SecondTableInA {
             _bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.py b/tests/namespace_test/NamespaceA/SecondTableInA.py
index 20dac3e..5aaa8ed 100644
--- a/tests/namespace_test/NamespaceA/SecondTableInA.py
+++ b/tests/namespace_test/NamespaceA/SecondTableInA.py
@@ -3,6 +3,8 @@
 # namespace: NamespaceA
 
 import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
 
 class SecondTableInA(object):
     __slots__ = ['_tab']
@@ -23,7 +25,6 @@
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from .TableInC import TableInC
             obj = TableInC()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -32,3 +33,43 @@
 def SecondTableInAStart(builder): builder.StartObject(1)
 def SecondTableInAAddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0)
 def SecondTableInAEnd(builder): return builder.EndObject()
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class SecondTableInAT(object):
+
+    # SecondTableInAT
+    def __init__(self):
+        self.referToC = None  # type: Optional[TableInCT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        secondTableInA = SecondTableInA()
+        secondTableInA.Init(buf, pos)
+        return cls.InitFromObj(secondTableInA)
+
+    @classmethod
+    def InitFromObj(cls, secondTableInA):
+        x = SecondTableInAT()
+        x._UnPack(secondTableInA)
+        return x
+
+    # SecondTableInAT
+    def _UnPack(self, secondTableInA):
+        if secondTableInA is None:
+            return
+        if secondTableInA.ReferToC() is not None:
+            self.referToC = TableInCT.InitFromObj(secondTableInA.ReferToC())
+
+    # SecondTableInAT
+    def Pack(self, builder):
+        if self.referToC is not None:
+            referToC = self.referToC.Pack(builder)
+        SecondTableInAStart(builder)
+        if self.referToC is not None:
+            SecondTableInAAddReferToC(builder, referToC)
+        secondTableInA = SecondTableInAEnd(builder)
+        return secondTableInA
diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.cs b/tests/namespace_test/NamespaceA/TableInFirstNS.cs
index d0d8ed0..3d597d7 100644
--- a/tests/namespace_test/NamespaceA/TableInFirstNS.cs
+++ b/tests/namespace_test/NamespaceA/TableInFirstNS.cs
@@ -6,13 +6,14 @@
 {
 
 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;
 
 public struct TableInFirstNS : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
   public static TableInFirstNS GetRootAsTableInFirstNS(ByteBuffer _bb) { return GetRootAsTableInFirstNS(_bb, new TableInFirstNS()); }
   public static TableInFirstNS GetRootAsTableInFirstNS(ByteBuffer _bb, TableInFirstNS obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -23,6 +24,17 @@
   public bool MutateFooEnum(NamespaceA.NamespaceB.EnumInNestedNS foo_enum) { int o = __p.__offset(6); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)foo_enum); return true; } else { return false; } }
   public NamespaceA.NamespaceB.StructInNestedNS? FooStruct { get { int o = __p.__offset(8); return o != 0 ? (NamespaceA.NamespaceB.StructInNestedNS?)(new NamespaceA.NamespaceB.StructInNestedNS()).__assign(o + __p.bb_pos, __p.bb) : null; } }
 
+  public static Offset<NamespaceA.TableInFirstNS> CreateTableInFirstNS(FlatBufferBuilder builder,
+      Offset<NamespaceA.NamespaceB.TableInNestedNS> foo_tableOffset = default(Offset<NamespaceA.NamespaceB.TableInNestedNS>),
+      NamespaceA.NamespaceB.EnumInNestedNS foo_enum = NamespaceA.NamespaceB.EnumInNestedNS.A,
+      NamespaceA.NamespaceB.StructInNestedNST foo_struct = null) {
+    builder.StartTable(3);
+    TableInFirstNS.AddFooStruct(builder, NamespaceA.NamespaceB.StructInNestedNS.Pack(builder, foo_struct));
+    TableInFirstNS.AddFooTable(builder, foo_tableOffset);
+    TableInFirstNS.AddFooEnum(builder, foo_enum);
+    return TableInFirstNS.EndTableInFirstNS(builder);
+  }
+
   public static void StartTableInFirstNS(FlatBufferBuilder builder) { builder.StartTable(3); }
   public static void AddFooTable(FlatBufferBuilder builder, Offset<NamespaceA.NamespaceB.TableInNestedNS> fooTableOffset) { builder.AddOffset(0, fooTableOffset.Value, 0); }
   public static void AddFooEnum(FlatBufferBuilder builder, NamespaceA.NamespaceB.EnumInNestedNS fooEnum) { builder.AddSbyte(1, (sbyte)fooEnum, 0); }
@@ -31,7 +43,42 @@
     int o = builder.EndTable();
     return new Offset<NamespaceA.TableInFirstNS>(o);
   }
+  public TableInFirstNST UnPack() {
+    var _o = new TableInFirstNST();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(TableInFirstNST _o) {
+    _o.FooTable = this.FooTable.HasValue ? this.FooTable.Value.UnPack() : null;
+    _o.FooEnum = this.FooEnum;
+    _o.FooStruct = this.FooStruct.HasValue ? this.FooStruct.Value.UnPack() : null;
+  }
+  public static Offset<NamespaceA.TableInFirstNS> Pack(FlatBufferBuilder builder, TableInFirstNST _o) {
+    if (_o == null) return default(Offset<NamespaceA.TableInFirstNS>);
+    var _foo_table = _o.FooTable == null ? default(Offset<NamespaceA.NamespaceB.TableInNestedNS>) : NamespaceA.NamespaceB.TableInNestedNS.Pack(builder, _o.FooTable);
+    return CreateTableInFirstNS(
+      builder,
+      _foo_table,
+      _o.FooEnum,
+      _o.FooStruct);
+  }
 };
 
+public class TableInFirstNST
+{
+  [Newtonsoft.Json.JsonProperty("foo_table")]
+  public NamespaceA.NamespaceB.TableInNestedNST FooTable { get; set; }
+  [Newtonsoft.Json.JsonProperty("foo_enum")]
+  public NamespaceA.NamespaceB.EnumInNestedNS FooEnum { get; set; }
+  [Newtonsoft.Json.JsonProperty("foo_struct")]
+  public NamespaceA.NamespaceB.StructInNestedNST FooStruct { get; set; }
+
+  public TableInFirstNST() {
+    this.FooTable = null;
+    this.FooEnum = NamespaceA.NamespaceB.EnumInNestedNS.A;
+    this.FooStruct = new NamespaceA.NamespaceB.StructInNestedNST();
+  }
+}
+
 
 }
diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.go b/tests/namespace_test/NamespaceA/TableInFirstNS.go
index bbcbdc6..7f419b8 100644
--- a/tests/namespace_test/NamespaceA/TableInFirstNS.go
+++ b/tests/namespace_test/NamespaceA/TableInFirstNS.go
@@ -8,6 +8,36 @@
 	NamespaceA__NamespaceB "NamespaceA/NamespaceB"
 )
 
+type TableInFirstNST struct {
+	FooTable *NamespaceA__NamespaceB.TableInNestedNST
+	FooEnum NamespaceA__NamespaceB.EnumInNestedNS
+	FooStruct *NamespaceA__NamespaceB.StructInNestedNST
+}
+
+func (t *TableInFirstNST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	if t == nil { return 0 }
+	fooTableOffset := t.FooTable.Pack(builder)
+	TableInFirstNSStart(builder)
+	TableInFirstNSAddFooTable(builder, fooTableOffset)
+	TableInFirstNSAddFooEnum(builder, t.FooEnum)
+	fooStructOffset := t.FooStruct.Pack(builder)
+	TableInFirstNSAddFooStruct(builder, fooStructOffset)
+	return TableInFirstNSEnd(builder)
+}
+
+func (rcv *TableInFirstNS) UnPackTo(t *TableInFirstNST) {
+	t.FooTable = rcv.FooTable(nil).UnPack()
+	t.FooEnum = rcv.FooEnum()
+	t.FooStruct = rcv.FooStruct(nil).UnPack()
+}
+
+func (rcv *TableInFirstNS) UnPack() *TableInFirstNST {
+	if rcv == nil { return nil }
+	t := &TableInFirstNST{}
+	rcv.UnPackTo(t)
+	return t
+}
+
 type TableInFirstNS struct {
 	_tab flatbuffers.Table
 }
@@ -19,6 +49,13 @@
 	return x
 }
 
+func GetSizePrefixedRootAsTableInFirstNS(buf []byte, offset flatbuffers.UOffsetT) *TableInFirstNS {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &TableInFirstNS{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
 func (rcv *TableInFirstNS) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i
diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.java b/tests/namespace_test/NamespaceA/TableInFirstNS.java
index e097381..f04d9e9 100644
--- a/tests/namespace_test/NamespaceA/TableInFirstNS.java
+++ b/tests/namespace_test/NamespaceA/TableInFirstNS.java
@@ -9,7 +9,7 @@
 
 @SuppressWarnings("unused")
 public final class TableInFirstNS extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
   public static TableInFirstNS getRootAsTableInFirstNS(ByteBuffer _bb) { return getRootAsTableInFirstNS(_bb, new TableInFirstNS()); }
   public static TableInFirstNS getRootAsTableInFirstNS(ByteBuffer _bb, TableInFirstNS obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -30,5 +30,12 @@
     int o = builder.endTable();
     return o;
   }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public TableInFirstNS get(int j) { return get(new TableInFirstNS(), j); }
+    public TableInFirstNS get(TableInFirstNS obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
 }
 
diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.kt b/tests/namespace_test/NamespaceA/TableInFirstNS.kt
index 1ba0afc..febe050 100644
--- a/tests/namespace_test/NamespaceA/TableInFirstNS.kt
+++ b/tests/namespace_test/NamespaceA/TableInFirstNS.kt
@@ -50,7 +50,7 @@
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+        fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
         fun getRootAsTableInFirstNS(_bb: ByteBuffer): TableInFirstNS = getRootAsTableInFirstNS(_bb, TableInFirstNS())
         fun getRootAsTableInFirstNS(_bb: ByteBuffer, obj: TableInFirstNS): TableInFirstNS {
             _bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.py b/tests/namespace_test/NamespaceA/TableInFirstNS.py
index 40cbeba..39598f5 100644
--- a/tests/namespace_test/NamespaceA/TableInFirstNS.py
+++ b/tests/namespace_test/NamespaceA/TableInFirstNS.py
@@ -3,6 +3,8 @@
 # namespace: NamespaceA
 
 import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
 
 class TableInFirstNS(object):
     __slots__ = ['_tab']
@@ -23,7 +25,6 @@
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from .TableInNestedNS import TableInNestedNS
             obj = TableInNestedNS()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -41,7 +42,6 @@
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
             x = o + self._tab.Pos
-            from .StructInNestedNS import StructInNestedNS
             obj = StructInNestedNS()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -52,3 +52,52 @@
 def TableInFirstNSAddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0)
 def TableInFirstNSAddFooStruct(builder, fooStruct): builder.PrependStructSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0)
 def TableInFirstNSEnd(builder): return builder.EndObject()
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class TableInFirstNST(object):
+
+    # TableInFirstNST
+    def __init__(self):
+        self.fooTable = None  # type: Optional[TableInNestedNST]
+        self.fooEnum = 0  # type: int
+        self.fooStruct = None  # type: Optional[StructInNestedNST]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        tableInFirstNS = TableInFirstNS()
+        tableInFirstNS.Init(buf, pos)
+        return cls.InitFromObj(tableInFirstNS)
+
+    @classmethod
+    def InitFromObj(cls, tableInFirstNS):
+        x = TableInFirstNST()
+        x._UnPack(tableInFirstNS)
+        return x
+
+    # TableInFirstNST
+    def _UnPack(self, tableInFirstNS):
+        if tableInFirstNS is None:
+            return
+        if tableInFirstNS.FooTable() is not None:
+            self.fooTable = TableInNestedNST.InitFromObj(tableInFirstNS.FooTable())
+        self.fooEnum = tableInFirstNS.FooEnum()
+        if tableInFirstNS.FooStruct() is not None:
+            self.fooStruct = StructInNestedNST.InitFromObj(tableInFirstNS.FooStruct())
+
+    # TableInFirstNST
+    def Pack(self, builder):
+        if self.fooTable is not None:
+            fooTable = self.fooTable.Pack(builder)
+        TableInFirstNSStart(builder)
+        if self.fooTable is not None:
+            TableInFirstNSAddFooTable(builder, fooTable)
+        TableInFirstNSAddFooEnum(builder, self.fooEnum)
+        if self.fooStruct is not None:
+            fooStruct = self.fooStruct.Pack(builder)
+            TableInFirstNSAddFooStruct(builder, fooStruct)
+        tableInFirstNS = TableInFirstNSEnd(builder)
+        return tableInFirstNS