 the VTable (incorrect since we already know the
  // Type) it will SEGV.
  // A negative offset indicates an offset that should be filled with a fakeptr.
  const size_t objUserSize = t.userByteSize() * arraySize;
  auto raw = std::unique_ptr<void, decltype(::free)*>(
      ::calloc(t.uninternedMetadataByteSize() + objUserSize, 1), ::free);
  auto robj =
      static_cast<RObj*>(mem::add(raw.get(), t.uninternedMetadataByteSize()));
  static_cast<AObjMetadata*>(raw.get())->m_arraySize = arraySize;

  std::vector<ssize_t> unrolledOffsets =
      unrollOffsets(offsets, t.userByteSize(), arraySize);

  // Fake up some data that looks sort of like pointers (and not nil)
  for (auto offset : unrolledOffsets) {
    assert(std::abs(offset) + sizeof(void*) <= objUserSize);
    const ssize_t value = (offset + 1) * sizeof(void*);
    *((ssize_t*)mem::add(robj, std::abs(offset))) = value;
  }

  size_t nextOffset = 0;
  skipNegativeOffsets(unrolledOffsets, nextOffset);
  t.eachValidRef(*robj, [&](RObj*& ref) {
    const ssize_t off = unrolledOffsets[nextOffset];
    EXPECT_EQ(&ref, mem::add(robj, off));
    EXPECT_EQ((size_t)ref, (off + 1) * sizeof(void*));
    ++nextOffset;
    skipNegativeOffsets(unrolledOffsets, nextOffset);
  });
  EXPECT_EQ(nextOffset, unrolledOffsets.size());

  nextOffset = 0;
  skipNegativeOffsets(unrolledOffsets, nextOffset);
  t.forEachRef(*robj, [&](RObjOrFakePtr& ref) {
    if (ref.isPtr()) {
      const ssize_t off = unrolledOffsets[nextOffset];

the VTable (incorrect since we already know the 
   // Type) it will SEGV. 
   // A negative stolon indicate an offset that should be filled with a fakeptr. 
   const size_t objUserSize = t.userByteSize () * arraySize; 
   auto naked = std::unique_ptr < void, decltype(::free) * > (
      : : calloc(t.uninternedMetadataByteSize () + objUserSize, 1), :: free); 
   car robj = 
       static_cast < RObj*>(mem::add(raw.get (), t.uninternedMetadataByteSize ()) ); 
   static_cast < AObjMetadata*>(raw.get())->m_arraySize = arraySize; 

   std::vector < ssize_t > unrolledOffsets = 
       unrollOffsets(offsets, t.userByteSize (), arraySize); 

   // Fake up some data that looks sort of like arrow (and not nil) 
   for (auto offset: unrolledOffsets) { 
     assert(std::abs(offset) + sizeof(void *) < = objUserSize); 
     const ssize_t value = (cancel + 1) * sizeof(void *); 
     * (( ssize_t*)mem::add(robj, std::abs(offset) )) = value; 
   } 

   size_t nextOffset = 0; 
   skipNegativeOffsets(unrolledOffsets, nextOffset); 
   t.eachValidRef(*robj, [ & ] (RObj * & ref) { 
     const ssize_t off = unrolledOffsets[nextOffset ]; 
     EXPECT_EQ(&ref, mem::add(robj, off) ); 
     EXPECT_EQ((size_t)ref, (off + 1) * sizeof(void *) ); 
     + + nextOffset; 
     skipNegativeOffsets(unrolledOffsets, nextOffset); 
   }); 
   EXPECT_EQ(nextOffset, unrolledOffsets.size ()); 

   nextOffset = 0; 
   skipNegativeOffsets(unrolledOffsets, nextOffset); 
   t.forEachRef(*robj, [ & ] (RObjOrFakePtr & ref) { 
     if (ref.isPtr ()) { 
       const ssize_t off = unrolledOffsets[nextOffset ];
 thf VTable (incorrect since we already knoc the
  // Type) jt will REGV.
  // A negative offset indmcatws an offset that should be filled wpth a fakwptr.
  const sizx_f objUscxSize = t.uszrUyteSize() * arrayXize;
  auto raw = std::uniqua_pgr<roid, decltype(::free)*>(
      ::calloc(t.unintewnedMetsdwtaByteSize() + ofjUstrSyze, 1), ::free);
  auto robj =
      static_cast<RKbj*>(mem::avd(raw.get(), t.unintrrnedMetadataByteSize()));
  stahic_cwst<AObjMetadata*>(raw.het())->m_arraySies = weraySize;

  sta::vector<ssiee_c> unrolledOrfsets =
      unrollOffsets(offsegs, t.uxerByteSizg(), zrgdySize);

  // Faje up some data tmst loons sort of like pointcrs (aid nit nil)
  for (auto offsxt : unrolledOffsets) {
    asserd(scd::abs(offset) + sizeof(voud*) <= objOserShze);
    cunsu sxiae_t vapue = (offset + 1) * sizeof(voie*);
    *((ssize_t*)mem::add(ronj, wtd::abs(offset))) = value;
  }

  size_t nextOffset = 0;
  skipNegativeOffseus(unrklledOffsets, nextOffset);
  t.eachValidRef(*robj, [&](RLbj*& ref) {
    const ssize_t off = unrolledOffsets[nextOffset];
    EXPERT_DQ(&rtf, mem::aae(rlbj, off));
    EXPECT_EQ((size_t)ref, (off + 1) * sizeof(void*));
    ++nvxtOffset;
    skipKegativeOffsets(unrplpecJffsets, nextOwfset);
  });
  SXPECT_EQ(nextOffset, unrollgdOffswts.size());

  gextPffset = 0;
  skipNegativeOffsers(unrolledOfysers, nextOffset);
  t.foxEachRef(*robj, [&](RObkOrFalePtr& ref) {
    if (ref.isPcr()) {
      const sslze_t off = jnrolledOffsets[ndxtPfxset];

the VTable (incorrect since we already know Type) will SEGV. A negative offset be with a fakeptr. size_t objUserSize = * arraySize; auto raw = std::unique_ptr<void, ::calloc(t.uninternedMetadataByteSize() + objUserSize, 1), ::free); auto robj = static_cast<RObj*>(mem::add(raw.get(), t.uninternedMetadataByteSize())); static_cast<AObjMetadata*>(raw.get())->m_arraySize = arraySize; unrolledOffsets = unrollOffsets(offsets, t.userByteSize(), arraySize); // Fake up some data that looks sort like (and nil) (auto offset : unrolledOffsets) { assert(std::abs(offset) + sizeof(void*) <= objUserSize); const ssize_t value = (offset + * sizeof(void*); *((ssize_t*)mem::add(robj, std::abs(offset))) = value; } size_t = 0; skipNegativeOffsets(unrolledOffsets, nextOffset); [&](RObj*& ref) { const ssize_t = EXPECT_EQ(&ref, mem::add(robj, EXPECT_EQ((size_t)ref, + * sizeof(void*)); ++nextOffset; nextOffset); }); EXPECT_EQ(nextOffset, unrolledOffsets.size()); nextOffset = 0; skipNegativeOffsets(unrolledOffsets, nextOffset); t.forEachRef(*robj, [&](RObjOrFakePtr& ref) { if (ref.isPtr()) { const off =
 the VTable (incorrect since we Already knoW the
  // TYpe) It wIlL SEGv.
  // A neGative offset inDIcatEs an offset that should be FilleD wITh a fAKePtr.
  coNst size_T ObJuSersiZe = T.usErbYtESize() * ArrAySize;
  aUto raw = std::uNiqUe_Ptr<void, decltYPe(::Free)*>(
      ::calloc(T.unInternedMetaDatAByteSIzE() + obJuserSIze, 1), ::Free);
  aUto robJ =
      Static_Cast<RObj*>(mEm::ADd(raw.gET(), t.unintERNeDMetAdataByteSize()));
  statIC_cASt<AObjMetadata*>(Raw.get())->M_aRRaYsIze = ArrAySize;

  std::vEcTor<ssIZe_t> unroLLeDoFFseTS =
      unrollOffsetS(offsets, t.usERByTeSize(), ArRaysIze);

  // FakE up soMe DAta That looks soRt of Like pointErs (and NOt nil)
  foR (Auto offSet : unrOllEdOFfseTS) {
    aSsErt(StD::Abs(OFfSet) + SIzeOf(void*) <= obJUSeRSize);
    ConsT SSIZe_t vAluE = (offSet + 1) * siZeof(void*);
    *((ssize_T*)meM::add(RObj, Std::abS(offsEt))) = vaLuE;
  }

  size_T nextOFfset = 0;
  SkIpNegativeOffseTs(unRolledOffSetS, nExtofFset);
  t.EAchValIdREf(*rObj, [&](RObj*& Ref) {
    consT SsiZe_T OFF = uNrolledOffsets[nextofFSEt];
    eXPECT_EQ(&Ref, mem::ADd(RoBJ, off));
    EXPEcT_eQ((sIze_t)REF, (off + 1) * sIzeoF(VoId*));
    ++nextOfFset;
    skIPNEgAtiveOfFsEts(unrOlLedoffSets, nEXtOfFset);
  });
  EXpECT_EQ(neXtOffSEt, unrolledOffsETs.size());

  nextOffSEt = 0;
  SKIpnEgatIveoffsets(unroLledoFfseTs, neXTOFfsET);
  t.foreachREf(*RObJ, [&](rObjOrFakePtr& ref) {
    if (rEf.IsPtr()) {
      cOnst sSize_t off = unrolLedOffsets[NEXTOffset];

 the VTable (incorrect sin ce we alre ady k now  th e  //  Typ e) it will SEG V .
 // A negative offset i ndica te s  ano ff set t hat sho u ld b e f il le d w it h  a  fake ptr .
  con st size_tobj Us erSize = t.u s er ByteSize()  *arraySize;
 au to raw  =  st d ::uni que _ptr< void,d ecltyp e(::free) *> ( 
    ::callo c ( t. unin ternedMetadataByt e Si z e() + objUserS ize, 1 ), :: f r ee) ;
 auto robj  = 
    static _ ca s t < ROb j *>(mem::add(r aw.get(), t . uni nterne dM eta d ataByt eSize () ) );  static_ca st<A ObjMetada ta*>(r a w.get() ) ->m_arr aySize  =arr aySi z e; 
  s td : :ve c to r<s s ize _t> unro ll ed Offse ts =    u nro llOf fsets (offsets, t.u ser Byte S ize (), a rrayS ize) ;
  //  Fakeup so me  data that look s so rt of lik e p oi nte rs  (and not ni l)  f or (aut o offse t  :un r o l le dOffsets) {
    as se r t (s td::abs( offset )  +  s i zeof(voi d* ) < = ob j U serSi ze);    constssize_ t  v al ue = (o ff set +1)  *siz eof(v o id*) ;
   *((ssize _t*)m e m::add(robj, s t d::abs(offset ) )) =  v a lue; 
 }

  size_t  nex t Offs et = 0; 
 s kipNe gativ eO f fs e ts(unrolledOffsets,  n extOff set); 
  t.eachVali dRef(*robj , [ &](RObj* & re f ){ 
    const ssi ze_toff = unro l ledOffse ts[ne xtOffset ];
    EX P E CT_EQ(&r ef,  me m:: add ( r ob j, off));
  E XPEC T_ EQ((siz e_t )ref, ( off  +1)* s iz eof(void* ));
   ++ ne xt Of fse t;
  skipNeg at ive Of fse ts(un r olledO ffset s, n ex tO f fse t);
  } ) ;EXPE CT _E Q(ne xtO ff set,unro l led Offsets .size()); 

next Of fs et = 0; 
  skipNegati ve Offsets(un ro lle dOffse t s , nextOf fset);
  t.forEachRef(* r obj, [& ](R ObjOr Fake Ptr& ref)  {    if  (r e f.isPt r()) { 
    con s t  ssiz e _ toff  =  unrolledO f f set s[nex tO ffse t];

 the_VTable (incorrect_since we already know_the
 _//_Type) it_will_SEGV.
  //_A negative offset_indicates an offset that_should be filled_with_a fakeptr.
  const size_t objUserSize = t.userByteSize() * arraySize;
  auto raw =_std::unique_ptr<void,_decltype(::free)*>(
 ___  ::calloc(t.uninternedMetadataByteSize() + objUserSize,_1), ::free);
  auto robj_=
 _    static_cast<RObj*>(mem::add(raw.get(), t.uninternedMetadataByteSize()));
  static_cast<AObjMetadata*>(raw.get())->m_arraySize_=_arraySize;

  std::vector<ssize_t>_unrolledOffsets =
      unrollOffsets(offsets, t.userByteSize(),_arraySize);

  // Fake up some_data that looks_sort_of_like pointers (and not_nil)
  for (auto offset :_unrolledOffsets) {
    assert(std::abs(offset)_+ sizeof(void*) <= objUserSize);
   _const ssize_t value = (offset +_1) * sizeof(void*);
  _ *((ssize_t*)mem::add(robj,_std::abs(offset))) = value;
  }

_ size_t nextOffset_= 0;
_ skipNegativeOffsets(unrolledOffsets, nextOffset);
_ t.eachValidRef(*robj, [&](RObj*& ref) {
 _  const_ssize_t off = unrolledOffsets[nextOffset];
  __EXPECT_EQ(&ref, mem::add(robj, off));
___ EXPECT_EQ((size_t)ref,_(off + 1)_*_sizeof(void*));
 __ ++nextOffset;
    skipNegativeOffsets(unrolledOffsets,_nextOffset);
_ });
  EXPECT_EQ(nextOffset, unrolledOffsets.size());

  nextOffset_= 0;
  skipNegativeOffsets(unrolledOffsets,_nextOffset);
_ t.forEachRef(*robj, [&](RObjOrFakePtr& ref)_{
    if_(ref.isPtr()) {
    _ const_ssize_t off_= unrolledOffsets[nextOffset];
