// This file is distributed under the University of Illinois Open Source License.
// See LICENSE.TXT for details.
// RUN: c_compiler -c -o %t1.o -I "common" "common/testsuite.c"
// RUN: c_compiler -c %s -I "common" -o %t2.o
// RUN: linker -o %t1%exeext  %t1.o %t2.o
// RUN: runtool %t1%exeext | checker "TEST PASSED"
#include "testsuite.h"

struct  STT010  {
  char fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT010) C1{ Fc Fc:0 Fc}



static void Test_STT010()
{
  {
    init_simple_test("STT010");
    static STRUCT_IF_C STT010 lv;
    check2(sizeof(lv), 2, "sizeof(STT010)");
    check2(__alignof__(lv), 1, "__alignof__(STT010)");
    check_field_offset(lv, fa, 0, "STT010.fa");
    check_field_offset(lv, fb, 1, "STT010.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT010, STT010)
//============================================================================


struct  STT020  {
  char fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT020) C1{ Fc Fs:0 Fc}



static void Test_STT020()
{
  {
    init_simple_test("STT020");
    static STRUCT_IF_C STT020 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT020)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT020)");
    check_field_offset(lv, fa, 0, "STT020.fa");
    check_field_offset(lv, fb, 2, "STT020.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT020, STT020)
//============================================================================


struct  STT030  {
  char fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT030) C1{ Fc Fi:0 Fc}



static void Test_STT030()
{
  {
    init_simple_test("STT030");
    static STRUCT_IF_C STT030 lv;
    check2(sizeof(lv), ABISELECT(5,5), "sizeof(STT030)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT030)");
    check_field_offset(lv, fa, 0, "STT030.fa");
    check_field_offset(lv, fb, 4, "STT030.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT030, STT030)
//============================================================================


struct  STT040  {
  char fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT040) C1{ Fc FL:0 Fc}



static void Test_STT040()
{
  {
    init_simple_test("STT040");
    static STRUCT_IF_C STT040 lv;
    check2(sizeof(lv), ABISELECT(9,5), "sizeof(STT040)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT040)");
    check_field_offset(lv, fa, 0, "STT040.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT040.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT040, STT040)
//============================================================================


struct  STT050  {
  char fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT050) C1{ Fc Fc:3 Fc}



static void Test_STT050()
{
  {
    init_simple_test("STT050");
    static STRUCT_IF_C STT050 lv;
    check2(sizeof(lv), 3, "sizeof(STT050)");
    check2(__alignof__(lv), 1, "__alignof__(STT050)");
    check_field_offset(lv, fa, 0, "STT050.fa");
    check_field_offset(lv, fb, 2, "STT050.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT050, STT050)
//============================================================================


struct  STT060  {
  char fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT060) C1{ Fc Fs:3 Fc}



static void Test_STT060()
{
  {
    init_simple_test("STT060");
    static STRUCT_IF_C STT060 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT060)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT060)");
    check_field_offset(lv, fa, 0, "STT060.fa");
    check_field_offset(lv, fb, 2, "STT060.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT060, STT060)
//============================================================================


struct  STT070  {
  char fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT070) C1{ Fc Fi:3 Fc}



static void Test_STT070()
{
  {
    init_simple_test("STT070");
    static STRUCT_IF_C STT070 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT070)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT070)");
    check_field_offset(lv, fa, 0, "STT070.fa");
    check_field_offset(lv, fb, 2, "STT070.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT070, STT070)
//============================================================================


struct  STT080  {
  char fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT080) C1{ Fc FL:3 Fc}



static void Test_STT080()
{
  {
    init_simple_test("STT080");
    static STRUCT_IF_C STT080 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT080)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT080)");
    check_field_offset(lv, fa, 0, "STT080.fa");
    check_field_offset(lv, fb, 2, "STT080.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT080, STT080)
//============================================================================


struct  STT090  {
  char fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT090) C1{ Fc Fs:8 Fc}



static void Test_STT090()
{
  {
    init_simple_test("STT090");
    static STRUCT_IF_C STT090 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT090)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT090)");
    check_field_offset(lv, fa, 0, "STT090.fa");
    check_field_offset(lv, fb, 2, "STT090.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT090, STT090)
//============================================================================


struct  STT0100  {
  char fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT0100) C1{ Fc Fi:8 Fc}



static void Test_STT0100()
{
  {
    init_simple_test("STT0100");
    static STRUCT_IF_C STT0100 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT0100)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0100)");
    check_field_offset(lv, fa, 0, "STT0100.fa");
    check_field_offset(lv, fb, 2, "STT0100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0100, STT0100)
//============================================================================


struct  STT0110  {
  char fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT0110) C1{ Fc FL:8 Fc}



static void Test_STT0110()
{
  {
    init_simple_test("STT0110");
    static STRUCT_IF_C STT0110 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT0110)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0110)");
    check_field_offset(lv, fa, 0, "STT0110.fa");
    check_field_offset(lv, fb, 2, "STT0110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0110, STT0110)
//============================================================================


struct  STT0120  {
  char fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT0120) C1{ Fc Fi:18 Fc}



static void Test_STT0120()
{
  {
    init_simple_test("STT0120");
    static STRUCT_IF_C STT0120 lv;
    check2(sizeof(lv), ABISELECT(5,5), "sizeof(STT0120)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0120)");
    check_field_offset(lv, fa, 0, "STT0120.fa");
    check_field_offset(lv, fb, 4, "STT0120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0120, STT0120)
//============================================================================


struct  STT0130  {
  char fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT0130) C1{ Fc FL:18 Fc}



static void Test_STT0130()
{
  {
    init_simple_test("STT0130");
    static STRUCT_IF_C STT0130 lv;
    check2(sizeof(lv), ABISELECT(5,5), "sizeof(STT0130)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0130)");
    check_field_offset(lv, fa, 0, "STT0130.fa");
    check_field_offset(lv, fb, 4, "STT0130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0130, STT0130)
//============================================================================


struct  STT0140  {
  char fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT0140) C1{ Fc FL:48 Fc}



static void Test_STT0140()
{
  {
    init_simple_test("STT0140");
    static STRUCT_IF_C STT0140 lv;
    check2(sizeof(lv), 8, "sizeof(STT0140)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0140)");
    check_field_offset(lv, fa, 0, "STT0140.fa");
    check_field_offset(lv, fb, 7, "STT0140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0140, STT0140)
//============================================================================


struct  STT0150  {
  char fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT0150) C1{ Fc Fc:3 Fc}



static void Test_STT0150()
{
  {
    init_simple_test("STT0150");
    static STRUCT_IF_C STT0150 lv;
    check2(sizeof(lv), 3, "sizeof(STT0150)");
    check2(__alignof__(lv), 1, "__alignof__(STT0150)");
    check_field_offset(lv, fa, 0, "STT0150.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0150");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0150");
    check_field_offset(lv, fb, 2, "STT0150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0150, STT0150)
//============================================================================


struct  STT0160  {
  char fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT0160) C1{ Fc Fs:3 Fc}



static void Test_STT0160()
{
  {
    init_simple_test("STT0160");
    static STRUCT_IF_C STT0160 lv;
    check2(sizeof(lv), 4, "sizeof(STT0160)");
    check2(__alignof__(lv), 2, "__alignof__(STT0160)");
    check_field_offset(lv, fa, 0, "STT0160.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0160");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0160");
    check_field_offset(lv, fb, 2, "STT0160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0160, STT0160)
//============================================================================


struct  STT0170  {
  char fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT0170) C1{ Fc Fi:3 Fc}



static void Test_STT0170()
{
  {
    init_simple_test("STT0170");
    static STRUCT_IF_C STT0170 lv;
    check2(sizeof(lv), 4, "sizeof(STT0170)");
    check2(__alignof__(lv), 4, "__alignof__(STT0170)");
    check_field_offset(lv, fa, 0, "STT0170.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0170");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0170");
    check_field_offset(lv, fb, 2, "STT0170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0170, STT0170)
//============================================================================


struct  STT0180  {
  char fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT0180) C1{ Fc FL:3 Fc}



static void Test_STT0180()
{
  {
    init_simple_test("STT0180");
    static STRUCT_IF_C STT0180 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0180)");
    check_field_offset(lv, fa, 0, "STT0180.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0180");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0180");
    check_field_offset(lv, fb, 2, "STT0180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0180, STT0180)
//============================================================================


struct  STT0190  {
  char fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT0190) C1{ Fc Fs:8 Fc}



static void Test_STT0190()
{
  {
    init_simple_test("STT0190");
    static STRUCT_IF_C STT0190 lv;
    check2(sizeof(lv), 4, "sizeof(STT0190)");
    check2(__alignof__(lv), 2, "__alignof__(STT0190)");
    check_field_offset(lv, fa, 0, "STT0190.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0190");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0190");
    check_field_offset(lv, fb, 2, "STT0190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0190, STT0190)
//============================================================================


struct  STT0200  {
  char fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT0200) C1{ Fc Fi:8 Fc}



static void Test_STT0200()
{
  {
    init_simple_test("STT0200");
    static STRUCT_IF_C STT0200 lv;
    check2(sizeof(lv), 4, "sizeof(STT0200)");
    check2(__alignof__(lv), 4, "__alignof__(STT0200)");
    check_field_offset(lv, fa, 0, "STT0200.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0200");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0200");
    check_field_offset(lv, fb, 2, "STT0200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0200, STT0200)
//============================================================================


struct  STT0210  {
  char fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT0210) C1{ Fc FL:8 Fc}



static void Test_STT0210()
{
  {
    init_simple_test("STT0210");
    static STRUCT_IF_C STT0210 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0210)");
    check_field_offset(lv, fa, 0, "STT0210.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0210");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0210");
    check_field_offset(lv, fb, 2, "STT0210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0210, STT0210)
//============================================================================


struct  STT0220  {
  char fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT0220) C1{ Fc Fi:18 Fc}



static void Test_STT0220()
{
  {
    init_simple_test("STT0220");
    static STRUCT_IF_C STT0220 lv;
    check2(sizeof(lv), 8, "sizeof(STT0220)");
    check2(__alignof__(lv), 4, "__alignof__(STT0220)");
    check_field_offset(lv, fa, 0, "STT0220.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0220");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0220");
    check_field_offset(lv, fb, 4, "STT0220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0220, STT0220)
//============================================================================


struct  STT0230  {
  char fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT0230) C1{ Fc FL:18 Fc}



static void Test_STT0230()
{
  {
    init_simple_test("STT0230");
    static STRUCT_IF_C STT0230 lv;
    check2(sizeof(lv), 8, "sizeof(STT0230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0230)");
    check_field_offset(lv, fa, 0, "STT0230.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0230");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0230");
    check_field_offset(lv, fb, 4, "STT0230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0230, STT0230)
//============================================================================


struct  STT0240  {
  char fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT0240) C1{ Fc FL:48 Fc}



static void Test_STT0240()
{
  {
    init_simple_test("STT0240");
    static STRUCT_IF_C STT0240 lv;
    check2(sizeof(lv), 8, "sizeof(STT0240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0240)");
    check_field_offset(lv, fa, 0, "STT0240.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0240");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0240");
    check_field_offset(lv, fb, 7, "STT0240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0240, STT0240)
//============================================================================


struct  STT011  {
  char fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT011) C1{ Fc Fc:0 Fs}



static void Test_STT011()
{
  {
    init_simple_test("STT011");
    static STRUCT_IF_C STT011 lv;
    check2(sizeof(lv), 4, "sizeof(STT011)");
    check2(__alignof__(lv), 2, "__alignof__(STT011)");
    check_field_offset(lv, fa, 0, "STT011.fa");
    check_field_offset(lv, fb, 2, "STT011.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT011, STT011)
//============================================================================


struct  STT021  {
  char fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT021) C1{ Fc Fs:0 Fs}



static void Test_STT021()
{
  {
    init_simple_test("STT021");
    static STRUCT_IF_C STT021 lv;
    check2(sizeof(lv), 4, "sizeof(STT021)");
    check2(__alignof__(lv), 2, "__alignof__(STT021)");
    check_field_offset(lv, fa, 0, "STT021.fa");
    check_field_offset(lv, fb, 2, "STT021.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT021, STT021)
//============================================================================


struct  STT031  {
  char fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT031) C1{ Fc Fi:0 Fs}



static void Test_STT031()
{
  {
    init_simple_test("STT031");
    static STRUCT_IF_C STT031 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT031)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT031)");
    check_field_offset(lv, fa, 0, "STT031.fa");
    check_field_offset(lv, fb, 4, "STT031.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT031, STT031)
//============================================================================


struct  STT041  {
  char fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT041) C1{ Fc FL:0 Fs}



static void Test_STT041()
{
  {
    init_simple_test("STT041");
    static STRUCT_IF_C STT041 lv;
    check2(sizeof(lv), ABISELECT(10,6), "sizeof(STT041)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT041)");
    check_field_offset(lv, fa, 0, "STT041.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT041.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT041, STT041)
//============================================================================


struct  STT051  {
  char fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT051) C1{ Fc Fc:3 Fs}



static void Test_STT051()
{
  {
    init_simple_test("STT051");
    static STRUCT_IF_C STT051 lv;
    check2(sizeof(lv), 4, "sizeof(STT051)");
    check2(__alignof__(lv), 2, "__alignof__(STT051)");
    check_field_offset(lv, fa, 0, "STT051.fa");
    check_field_offset(lv, fb, 2, "STT051.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT051, STT051)
//============================================================================


struct  STT061  {
  char fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT061) C1{ Fc Fs:3 Fs}



static void Test_STT061()
{
  {
    init_simple_test("STT061");
    static STRUCT_IF_C STT061 lv;
    check2(sizeof(lv), 4, "sizeof(STT061)");
    check2(__alignof__(lv), 2, "__alignof__(STT061)");
    check_field_offset(lv, fa, 0, "STT061.fa");
    check_field_offset(lv, fb, 2, "STT061.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT061, STT061)
//============================================================================


struct  STT071  {
  char fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT071) C1{ Fc Fi:3 Fs}



static void Test_STT071()
{
  {
    init_simple_test("STT071");
    static STRUCT_IF_C STT071 lv;
    check2(sizeof(lv), 4, "sizeof(STT071)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT071)");
    check_field_offset(lv, fa, 0, "STT071.fa");
    check_field_offset(lv, fb, 2, "STT071.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT071, STT071)
//============================================================================


struct  STT081  {
  char fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT081) C1{ Fc FL:3 Fs}



static void Test_STT081()
{
  {
    init_simple_test("STT081");
    static STRUCT_IF_C STT081 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT081)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT081)");
    check_field_offset(lv, fa, 0, "STT081.fa");
    check_field_offset(lv, fb, 2, "STT081.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT081, STT081)
//============================================================================


struct  STT091  {
  char fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT091) C1{ Fc Fs:8 Fs}



static void Test_STT091()
{
  {
    init_simple_test("STT091");
    static STRUCT_IF_C STT091 lv;
    check2(sizeof(lv), 4, "sizeof(STT091)");
    check2(__alignof__(lv), 2, "__alignof__(STT091)");
    check_field_offset(lv, fa, 0, "STT091.fa");
    check_field_offset(lv, fb, 2, "STT091.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT091, STT091)
//============================================================================


struct  STT0101  {
  char fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT0101) C1{ Fc Fi:8 Fs}



static void Test_STT0101()
{
  {
    init_simple_test("STT0101");
    static STRUCT_IF_C STT0101 lv;
    check2(sizeof(lv), 4, "sizeof(STT0101)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT0101)");
    check_field_offset(lv, fa, 0, "STT0101.fa");
    check_field_offset(lv, fb, 2, "STT0101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0101, STT0101)
//============================================================================


struct  STT0111  {
  char fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT0111) C1{ Fc FL:8 Fs}



static void Test_STT0111()
{
  {
    init_simple_test("STT0111");
    static STRUCT_IF_C STT0111 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT0111)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT0111)");
    check_field_offset(lv, fa, 0, "STT0111.fa");
    check_field_offset(lv, fb, 2, "STT0111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0111, STT0111)
//============================================================================


struct  STT0121  {
  char fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT0121) C1{ Fc Fi:18 Fs}



static void Test_STT0121()
{
  {
    init_simple_test("STT0121");
    static STRUCT_IF_C STT0121 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT0121)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT0121)");
    check_field_offset(lv, fa, 0, "STT0121.fa");
    check_field_offset(lv, fb, 4, "STT0121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0121, STT0121)
//============================================================================


struct  STT0131  {
  char fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT0131) C1{ Fc FL:18 Fs}



static void Test_STT0131()
{
  {
    init_simple_test("STT0131");
    static STRUCT_IF_C STT0131 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT0131)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT0131)");
    check_field_offset(lv, fa, 0, "STT0131.fa");
    check_field_offset(lv, fb, 4, "STT0131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0131, STT0131)
//============================================================================


struct  STT0141  {
  char fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT0141) C1{ Fc FL:48 Fs}



static void Test_STT0141()
{
  {
    init_simple_test("STT0141");
    static STRUCT_IF_C STT0141 lv;
    check2(sizeof(lv), ABISELECT(10,10), "sizeof(STT0141)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT0141)");
    check_field_offset(lv, fa, 0, "STT0141.fa");
    check_field_offset(lv, fb, 8, "STT0141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0141, STT0141)
//============================================================================


struct  STT0151  {
  char fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT0151) C1{ Fc Fc:3 Fs}



static void Test_STT0151()
{
  {
    init_simple_test("STT0151");
    static STRUCT_IF_C STT0151 lv;
    check2(sizeof(lv), 4, "sizeof(STT0151)");
    check2(__alignof__(lv), 2, "__alignof__(STT0151)");
    check_field_offset(lv, fa, 0, "STT0151.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0151");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0151");
    check_field_offset(lv, fb, 2, "STT0151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0151, STT0151)
//============================================================================


struct  STT0161  {
  char fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT0161) C1{ Fc Fs:3 Fs}



static void Test_STT0161()
{
  {
    init_simple_test("STT0161");
    static STRUCT_IF_C STT0161 lv;
    check2(sizeof(lv), 4, "sizeof(STT0161)");
    check2(__alignof__(lv), 2, "__alignof__(STT0161)");
    check_field_offset(lv, fa, 0, "STT0161.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0161");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0161");
    check_field_offset(lv, fb, 2, "STT0161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0161, STT0161)
//============================================================================


struct  STT0171  {
  char fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT0171) C1{ Fc Fi:3 Fs}



static void Test_STT0171()
{
  {
    init_simple_test("STT0171");
    static STRUCT_IF_C STT0171 lv;
    check2(sizeof(lv), 4, "sizeof(STT0171)");
    check2(__alignof__(lv), 4, "__alignof__(STT0171)");
    check_field_offset(lv, fa, 0, "STT0171.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0171");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0171");
    check_field_offset(lv, fb, 2, "STT0171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0171, STT0171)
//============================================================================


struct  STT0181  {
  char fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT0181) C1{ Fc FL:3 Fs}



static void Test_STT0181()
{
  {
    init_simple_test("STT0181");
    static STRUCT_IF_C STT0181 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0181)");
    check_field_offset(lv, fa, 0, "STT0181.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0181");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0181");
    check_field_offset(lv, fb, 2, "STT0181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0181, STT0181)
//============================================================================


struct  STT0191  {
  char fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT0191) C1{ Fc Fs:8 Fs}



static void Test_STT0191()
{
  {
    init_simple_test("STT0191");
    static STRUCT_IF_C STT0191 lv;
    check2(sizeof(lv), 4, "sizeof(STT0191)");
    check2(__alignof__(lv), 2, "__alignof__(STT0191)");
    check_field_offset(lv, fa, 0, "STT0191.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0191");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0191");
    check_field_offset(lv, fb, 2, "STT0191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0191, STT0191)
//============================================================================


struct  STT0201  {
  char fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT0201) C1{ Fc Fi:8 Fs}



static void Test_STT0201()
{
  {
    init_simple_test("STT0201");
    static STRUCT_IF_C STT0201 lv;
    check2(sizeof(lv), 4, "sizeof(STT0201)");
    check2(__alignof__(lv), 4, "__alignof__(STT0201)");
    check_field_offset(lv, fa, 0, "STT0201.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0201");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0201");
    check_field_offset(lv, fb, 2, "STT0201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0201, STT0201)
//============================================================================


struct  STT0211  {
  char fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT0211) C1{ Fc FL:8 Fs}



static void Test_STT0211()
{
  {
    init_simple_test("STT0211");
    static STRUCT_IF_C STT0211 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0211)");
    check_field_offset(lv, fa, 0, "STT0211.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0211");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0211");
    check_field_offset(lv, fb, 2, "STT0211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0211, STT0211)
//============================================================================


struct  STT0221  {
  char fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT0221) C1{ Fc Fi:18 Fs}



static void Test_STT0221()
{
  {
    init_simple_test("STT0221");
    static STRUCT_IF_C STT0221 lv;
    check2(sizeof(lv), 8, "sizeof(STT0221)");
    check2(__alignof__(lv), 4, "__alignof__(STT0221)");
    check_field_offset(lv, fa, 0, "STT0221.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0221");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0221");
    check_field_offset(lv, fb, 4, "STT0221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0221, STT0221)
//============================================================================


struct  STT0231  {
  char fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT0231) C1{ Fc FL:18 Fs}



static void Test_STT0231()
{
  {
    init_simple_test("STT0231");
    static STRUCT_IF_C STT0231 lv;
    check2(sizeof(lv), 8, "sizeof(STT0231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0231)");
    check_field_offset(lv, fa, 0, "STT0231.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0231");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0231");
    check_field_offset(lv, fb, 4, "STT0231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0231, STT0231)
//============================================================================


struct  STT0241  {
  char fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT0241) C1{ Fc FL:48 Fs}



static void Test_STT0241()
{
  {
    init_simple_test("STT0241");
    static STRUCT_IF_C STT0241 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0241)");
    check_field_offset(lv, fa, 0, "STT0241.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0241");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0241");
    check_field_offset(lv, fb, 8, "STT0241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0241, STT0241)
//============================================================================


struct  STT012  {
  char fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT012) C1{ Fc Fc:0 Fi}



static void Test_STT012()
{
  {
    init_simple_test("STT012");
    static STRUCT_IF_C STT012 lv;
    check2(sizeof(lv), 8, "sizeof(STT012)");
    check2(__alignof__(lv), 4, "__alignof__(STT012)");
    check_field_offset(lv, fa, 0, "STT012.fa");
    check_field_offset(lv, fb, 4, "STT012.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT012, STT012)
//============================================================================


struct  STT022  {
  char fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT022) C1{ Fc Fs:0 Fi}



static void Test_STT022()
{
  {
    init_simple_test("STT022");
    static STRUCT_IF_C STT022 lv;
    check2(sizeof(lv), 8, "sizeof(STT022)");
    check2(__alignof__(lv), 4, "__alignof__(STT022)");
    check_field_offset(lv, fa, 0, "STT022.fa");
    check_field_offset(lv, fb, 4, "STT022.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT022, STT022)
//============================================================================


struct  STT032  {
  char fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT032) C1{ Fc Fi:0 Fi}



static void Test_STT032()
{
  {
    init_simple_test("STT032");
    static STRUCT_IF_C STT032 lv;
    check2(sizeof(lv), 8, "sizeof(STT032)");
    check2(__alignof__(lv), 4, "__alignof__(STT032)");
    check_field_offset(lv, fa, 0, "STT032.fa");
    check_field_offset(lv, fb, 4, "STT032.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT032, STT032)
//============================================================================


struct  STT042  {
  char fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT042) C1{ Fc FL:0 Fi}



static void Test_STT042()
{
  {
    init_simple_test("STT042");
    static STRUCT_IF_C STT042 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT042)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT042)");
    check_field_offset(lv, fa, 0, "STT042.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT042.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT042, STT042)
//============================================================================


struct  STT052  {
  char fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT052) C1{ Fc Fc:3 Fi}



static void Test_STT052()
{
  {
    init_simple_test("STT052");
    static STRUCT_IF_C STT052 lv;
    check2(sizeof(lv), 8, "sizeof(STT052)");
    check2(__alignof__(lv), 4, "__alignof__(STT052)");
    check_field_offset(lv, fa, 0, "STT052.fa");
    check_field_offset(lv, fb, 4, "STT052.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT052, STT052)
//============================================================================


struct  STT062  {
  char fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT062) C1{ Fc Fs:3 Fi}



static void Test_STT062()
{
  {
    init_simple_test("STT062");
    static STRUCT_IF_C STT062 lv;
    check2(sizeof(lv), 8, "sizeof(STT062)");
    check2(__alignof__(lv), 4, "__alignof__(STT062)");
    check_field_offset(lv, fa, 0, "STT062.fa");
    check_field_offset(lv, fb, 4, "STT062.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT062, STT062)
//============================================================================


struct  STT072  {
  char fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT072) C1{ Fc Fi:3 Fi}



static void Test_STT072()
{
  {
    init_simple_test("STT072");
    static STRUCT_IF_C STT072 lv;
    check2(sizeof(lv), 8, "sizeof(STT072)");
    check2(__alignof__(lv), 4, "__alignof__(STT072)");
    check_field_offset(lv, fa, 0, "STT072.fa");
    check_field_offset(lv, fb, 4, "STT072.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT072, STT072)
//============================================================================


struct  STT082  {
  char fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT082) C1{ Fc FL:3 Fi}



static void Test_STT082()
{
  {
    init_simple_test("STT082");
    static STRUCT_IF_C STT082 lv;
    check2(sizeof(lv), 8, "sizeof(STT082)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT082)");
    check_field_offset(lv, fa, 0, "STT082.fa");
    check_field_offset(lv, fb, 4, "STT082.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT082, STT082)
//============================================================================


struct  STT092  {
  char fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT092) C1{ Fc Fs:8 Fi}



static void Test_STT092()
{
  {
    init_simple_test("STT092");
    static STRUCT_IF_C STT092 lv;
    check2(sizeof(lv), 8, "sizeof(STT092)");
    check2(__alignof__(lv), 4, "__alignof__(STT092)");
    check_field_offset(lv, fa, 0, "STT092.fa");
    check_field_offset(lv, fb, 4, "STT092.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT092, STT092)
//============================================================================


struct  STT0102  {
  char fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT0102) C1{ Fc Fi:8 Fi}



static void Test_STT0102()
{
  {
    init_simple_test("STT0102");
    static STRUCT_IF_C STT0102 lv;
    check2(sizeof(lv), 8, "sizeof(STT0102)");
    check2(__alignof__(lv), 4, "__alignof__(STT0102)");
    check_field_offset(lv, fa, 0, "STT0102.fa");
    check_field_offset(lv, fb, 4, "STT0102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0102, STT0102)
//============================================================================


struct  STT0112  {
  char fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT0112) C1{ Fc FL:8 Fi}



static void Test_STT0112()
{
  {
    init_simple_test("STT0112");
    static STRUCT_IF_C STT0112 lv;
    check2(sizeof(lv), 8, "sizeof(STT0112)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT0112)");
    check_field_offset(lv, fa, 0, "STT0112.fa");
    check_field_offset(lv, fb, 4, "STT0112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0112, STT0112)
//============================================================================


struct  STT0122  {
  char fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT0122) C1{ Fc Fi:18 Fi}



static void Test_STT0122()
{
  {
    init_simple_test("STT0122");
    static STRUCT_IF_C STT0122 lv;
    check2(sizeof(lv), 8, "sizeof(STT0122)");
    check2(__alignof__(lv), 4, "__alignof__(STT0122)");
    check_field_offset(lv, fa, 0, "STT0122.fa");
    check_field_offset(lv, fb, 4, "STT0122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0122, STT0122)
//============================================================================


struct  STT0132  {
  char fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT0132) C1{ Fc FL:18 Fi}



static void Test_STT0132()
{
  {
    init_simple_test("STT0132");
    static STRUCT_IF_C STT0132 lv;
    check2(sizeof(lv), 8, "sizeof(STT0132)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT0132)");
    check_field_offset(lv, fa, 0, "STT0132.fa");
    check_field_offset(lv, fb, 4, "STT0132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0132, STT0132)
//============================================================================


struct  STT0142  {
  char fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT0142) C1{ Fc FL:48 Fi}



static void Test_STT0142()
{
  {
    init_simple_test("STT0142");
    static STRUCT_IF_C STT0142 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT0142)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT0142)");
    check_field_offset(lv, fa, 0, "STT0142.fa");
    check_field_offset(lv, fb, 8, "STT0142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0142, STT0142)
//============================================================================


struct  STT0152  {
  char fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT0152) C1{ Fc Fc:3 Fi}



static void Test_STT0152()
{
  {
    init_simple_test("STT0152");
    static STRUCT_IF_C STT0152 lv;
    check2(sizeof(lv), 8, "sizeof(STT0152)");
    check2(__alignof__(lv), 4, "__alignof__(STT0152)");
    check_field_offset(lv, fa, 0, "STT0152.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0152");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0152");
    check_field_offset(lv, fb, 4, "STT0152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0152, STT0152)
//============================================================================


struct  STT0162  {
  char fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT0162) C1{ Fc Fs:3 Fi}



static void Test_STT0162()
{
  {
    init_simple_test("STT0162");
    static STRUCT_IF_C STT0162 lv;
    check2(sizeof(lv), 8, "sizeof(STT0162)");
    check2(__alignof__(lv), 4, "__alignof__(STT0162)");
    check_field_offset(lv, fa, 0, "STT0162.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0162");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0162");
    check_field_offset(lv, fb, 4, "STT0162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0162, STT0162)
//============================================================================


struct  STT0172  {
  char fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT0172) C1{ Fc Fi:3 Fi}



static void Test_STT0172()
{
  {
    init_simple_test("STT0172");
    static STRUCT_IF_C STT0172 lv;
    check2(sizeof(lv), 8, "sizeof(STT0172)");
    check2(__alignof__(lv), 4, "__alignof__(STT0172)");
    check_field_offset(lv, fa, 0, "STT0172.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0172");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0172");
    check_field_offset(lv, fb, 4, "STT0172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0172, STT0172)
//============================================================================


struct  STT0182  {
  char fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT0182) C1{ Fc FL:3 Fi}



static void Test_STT0182()
{
  {
    init_simple_test("STT0182");
    static STRUCT_IF_C STT0182 lv;
    check2(sizeof(lv), 8, "sizeof(STT0182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0182)");
    check_field_offset(lv, fa, 0, "STT0182.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0182");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0182");
    check_field_offset(lv, fb, 4, "STT0182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0182, STT0182)
//============================================================================


struct  STT0192  {
  char fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT0192) C1{ Fc Fs:8 Fi}



static void Test_STT0192()
{
  {
    init_simple_test("STT0192");
    static STRUCT_IF_C STT0192 lv;
    check2(sizeof(lv), 8, "sizeof(STT0192)");
    check2(__alignof__(lv), 4, "__alignof__(STT0192)");
    check_field_offset(lv, fa, 0, "STT0192.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0192");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0192");
    check_field_offset(lv, fb, 4, "STT0192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0192, STT0192)
//============================================================================


struct  STT0202  {
  char fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT0202) C1{ Fc Fi:8 Fi}



static void Test_STT0202()
{
  {
    init_simple_test("STT0202");
    static STRUCT_IF_C STT0202 lv;
    check2(sizeof(lv), 8, "sizeof(STT0202)");
    check2(__alignof__(lv), 4, "__alignof__(STT0202)");
    check_field_offset(lv, fa, 0, "STT0202.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0202");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0202");
    check_field_offset(lv, fb, 4, "STT0202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0202, STT0202)
//============================================================================


struct  STT0212  {
  char fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT0212) C1{ Fc FL:8 Fi}



static void Test_STT0212()
{
  {
    init_simple_test("STT0212");
    static STRUCT_IF_C STT0212 lv;
    check2(sizeof(lv), 8, "sizeof(STT0212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0212)");
    check_field_offset(lv, fa, 0, "STT0212.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0212");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0212");
    check_field_offset(lv, fb, 4, "STT0212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0212, STT0212)
//============================================================================


struct  STT0222  {
  char fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT0222) C1{ Fc Fi:18 Fi}



static void Test_STT0222()
{
  {
    init_simple_test("STT0222");
    static STRUCT_IF_C STT0222 lv;
    check2(sizeof(lv), 8, "sizeof(STT0222)");
    check2(__alignof__(lv), 4, "__alignof__(STT0222)");
    check_field_offset(lv, fa, 0, "STT0222.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0222");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0222");
    check_field_offset(lv, fb, 4, "STT0222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0222, STT0222)
//============================================================================


struct  STT0232  {
  char fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT0232) C1{ Fc FL:18 Fi}



static void Test_STT0232()
{
  {
    init_simple_test("STT0232");
    static STRUCT_IF_C STT0232 lv;
    check2(sizeof(lv), 8, "sizeof(STT0232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0232)");
    check_field_offset(lv, fa, 0, "STT0232.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0232");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0232");
    check_field_offset(lv, fb, 4, "STT0232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0232, STT0232)
//============================================================================


struct  STT0242  {
  char fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT0242) C1{ Fc FL:48 Fi}



static void Test_STT0242()
{
  {
    init_simple_test("STT0242");
    static STRUCT_IF_C STT0242 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0242)");
    check_field_offset(lv, fa, 0, "STT0242.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0242");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0242");
    check_field_offset(lv, fb, 8, "STT0242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0242, STT0242)
//============================================================================


struct  STT013  {
  char fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT013) C1{ Fc Fc:0 Fl}



static void Test_STT013()
{
  {
    init_simple_test("STT013");
    static STRUCT_IF_C STT013 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT013)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT013)");
    check_field_offset(lv, fa, 0, "STT013.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT013.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT013, STT013)
//============================================================================


struct  STT023  {
  char fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT023) C1{ Fc Fs:0 Fl}



static void Test_STT023()
{
  {
    init_simple_test("STT023");
    static STRUCT_IF_C STT023 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT023)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT023)");
    check_field_offset(lv, fa, 0, "STT023.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT023.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT023, STT023)
//============================================================================


struct  STT033  {
  char fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT033) C1{ Fc Fi:0 Fl}



static void Test_STT033()
{
  {
    init_simple_test("STT033");
    static STRUCT_IF_C STT033 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT033)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT033)");
    check_field_offset(lv, fa, 0, "STT033.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT033.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT033, STT033)
//============================================================================


struct  STT043  {
  char fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT043) C1{ Fc FL:0 Fl}



static void Test_STT043()
{
  {
    init_simple_test("STT043");
    static STRUCT_IF_C STT043 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT043)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT043)");
    check_field_offset(lv, fa, 0, "STT043.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT043.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT043, STT043)
//============================================================================


struct  STT053  {
  char fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT053) C1{ Fc Fc:3 Fl}



static void Test_STT053()
{
  {
    init_simple_test("STT053");
    static STRUCT_IF_C STT053 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT053)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT053)");
    check_field_offset(lv, fa, 0, "STT053.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT053.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT053, STT053)
//============================================================================


struct  STT063  {
  char fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT063) C1{ Fc Fs:3 Fl}



static void Test_STT063()
{
  {
    init_simple_test("STT063");
    static STRUCT_IF_C STT063 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT063)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT063)");
    check_field_offset(lv, fa, 0, "STT063.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT063.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT063, STT063)
//============================================================================


struct  STT073  {
  char fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT073) C1{ Fc Fi:3 Fl}



static void Test_STT073()
{
  {
    init_simple_test("STT073");
    static STRUCT_IF_C STT073 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT073)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT073)");
    check_field_offset(lv, fa, 0, "STT073.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT073.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT073, STT073)
//============================================================================


struct  STT083  {
  char fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT083) C1{ Fc FL:3 Fl}



static void Test_STT083()
{
  {
    init_simple_test("STT083");
    static STRUCT_IF_C STT083 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT083)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT083)");
    check_field_offset(lv, fa, 0, "STT083.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT083.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT083, STT083)
//============================================================================


struct  STT093  {
  char fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT093) C1{ Fc Fs:8 Fl}



static void Test_STT093()
{
  {
    init_simple_test("STT093");
    static STRUCT_IF_C STT093 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT093)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT093)");
    check_field_offset(lv, fa, 0, "STT093.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT093.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT093, STT093)
//============================================================================


struct  STT0103  {
  char fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT0103) C1{ Fc Fi:8 Fl}



static void Test_STT0103()
{
  {
    init_simple_test("STT0103");
    static STRUCT_IF_C STT0103 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0103)");
    check_field_offset(lv, fa, 0, "STT0103.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0103, STT0103)
//============================================================================


struct  STT0113  {
  char fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT0113) C1{ Fc FL:8 Fl}



static void Test_STT0113()
{
  {
    init_simple_test("STT0113");
    static STRUCT_IF_C STT0113 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0113)");
    check_field_offset(lv, fa, 0, "STT0113.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0113, STT0113)
//============================================================================


struct  STT0123  {
  char fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT0123) C1{ Fc Fi:18 Fl}



static void Test_STT0123()
{
  {
    init_simple_test("STT0123");
    static STRUCT_IF_C STT0123 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0123)");
    check_field_offset(lv, fa, 0, "STT0123.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0123, STT0123)
//============================================================================


struct  STT0133  {
  char fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT0133) C1{ Fc FL:18 Fl}



static void Test_STT0133()
{
  {
    init_simple_test("STT0133");
    static STRUCT_IF_C STT0133 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0133)");
    check_field_offset(lv, fa, 0, "STT0133.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0133, STT0133)
//============================================================================


struct  STT0143  {
  char fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT0143) C1{ Fc FL:48 Fl}



static void Test_STT0143()
{
  {
    init_simple_test("STT0143");
    static STRUCT_IF_C STT0143 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0143)");
    check_field_offset(lv, fa, 0, "STT0143.fa");
    check_field_offset(lv, fb, 8, "STT0143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0143, STT0143)
//============================================================================


struct  STT0153  {
  char fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT0153) C1{ Fc Fc:3 Fl}



static void Test_STT0153()
{
  {
    init_simple_test("STT0153");
    static STRUCT_IF_C STT0153 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0153)");
    check_field_offset(lv, fa, 0, "STT0153.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0153");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0153");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0153, STT0153)
//============================================================================


struct  STT0163  {
  char fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT0163) C1{ Fc Fs:3 Fl}



static void Test_STT0163()
{
  {
    init_simple_test("STT0163");
    static STRUCT_IF_C STT0163 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0163)");
    check_field_offset(lv, fa, 0, "STT0163.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0163");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0163");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0163, STT0163)
//============================================================================


struct  STT0173  {
  char fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT0173) C1{ Fc Fi:3 Fl}



static void Test_STT0173()
{
  {
    init_simple_test("STT0173");
    static STRUCT_IF_C STT0173 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0173)");
    check_field_offset(lv, fa, 0, "STT0173.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0173");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0173");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0173, STT0173)
//============================================================================


struct  STT0183  {
  char fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT0183) C1{ Fc FL:3 Fl}



static void Test_STT0183()
{
  {
    init_simple_test("STT0183");
    static STRUCT_IF_C STT0183 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0183)");
    check_field_offset(lv, fa, 0, "STT0183.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0183");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0183");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0183, STT0183)
//============================================================================


struct  STT0193  {
  char fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT0193) C1{ Fc Fs:8 Fl}



static void Test_STT0193()
{
  {
    init_simple_test("STT0193");
    static STRUCT_IF_C STT0193 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0193)");
    check_field_offset(lv, fa, 0, "STT0193.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0193");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0193");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0193, STT0193)
//============================================================================


struct  STT0203  {
  char fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT0203) C1{ Fc Fi:8 Fl}



static void Test_STT0203()
{
  {
    init_simple_test("STT0203");
    static STRUCT_IF_C STT0203 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0203)");
    check_field_offset(lv, fa, 0, "STT0203.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0203");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0203");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0203, STT0203)
//============================================================================


struct  STT0213  {
  char fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT0213) C1{ Fc FL:8 Fl}



static void Test_STT0213()
{
  {
    init_simple_test("STT0213");
    static STRUCT_IF_C STT0213 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0213)");
    check_field_offset(lv, fa, 0, "STT0213.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0213");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0213");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0213, STT0213)
//============================================================================


struct  STT0223  {
  char fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT0223) C1{ Fc Fi:18 Fl}



static void Test_STT0223()
{
  {
    init_simple_test("STT0223");
    static STRUCT_IF_C STT0223 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0223)");
    check_field_offset(lv, fa, 0, "STT0223.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0223");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0223");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0223, STT0223)
//============================================================================


struct  STT0233  {
  char fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT0233) C1{ Fc FL:18 Fl}



static void Test_STT0233()
{
  {
    init_simple_test("STT0233");
    static STRUCT_IF_C STT0233 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0233)");
    check_field_offset(lv, fa, 0, "STT0233.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0233");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0233");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0233, STT0233)
//============================================================================


struct  STT0243  {
  char fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT0243) C1{ Fc FL:48 Fl}



static void Test_STT0243()
{
  {
    init_simple_test("STT0243");
    static STRUCT_IF_C STT0243 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0243)");
    check_field_offset(lv, fa, 0, "STT0243.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0243");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0243");
    check_field_offset(lv, fb, 8, "STT0243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0243, STT0243)
//============================================================================


struct  STT014  {
  char fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT014) C1{ Fc Fc:0 FL}



static void Test_STT014()
{
  {
    init_simple_test("STT014");
    static STRUCT_IF_C STT014 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT014)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT014)");
    check_field_offset(lv, fa, 0, "STT014.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT014.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT014, STT014)
//============================================================================


struct  STT024  {
  char fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT024) C1{ Fc Fs:0 FL}



static void Test_STT024()
{
  {
    init_simple_test("STT024");
    static STRUCT_IF_C STT024 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT024)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT024)");
    check_field_offset(lv, fa, 0, "STT024.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT024.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT024, STT024)
//============================================================================


struct  STT034  {
  char fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT034) C1{ Fc Fi:0 FL}



static void Test_STT034()
{
  {
    init_simple_test("STT034");
    static STRUCT_IF_C STT034 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT034)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT034)");
    check_field_offset(lv, fa, 0, "STT034.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT034.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT034, STT034)
//============================================================================


struct  STT044  {
  char fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT044) C1{ Fc FL:0 FL}



static void Test_STT044()
{
  {
    init_simple_test("STT044");
    static STRUCT_IF_C STT044 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT044)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT044)");
    check_field_offset(lv, fa, 0, "STT044.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT044.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT044, STT044)
//============================================================================


struct  STT054  {
  char fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT054) C1{ Fc Fc:3 FL}



static void Test_STT054()
{
  {
    init_simple_test("STT054");
    static STRUCT_IF_C STT054 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT054)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT054)");
    check_field_offset(lv, fa, 0, "STT054.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT054.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT054, STT054)
//============================================================================


struct  STT064  {
  char fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT064) C1{ Fc Fs:3 FL}



static void Test_STT064()
{
  {
    init_simple_test("STT064");
    static STRUCT_IF_C STT064 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT064)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT064)");
    check_field_offset(lv, fa, 0, "STT064.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT064.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT064, STT064)
//============================================================================


struct  STT074  {
  char fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT074) C1{ Fc Fi:3 FL}



static void Test_STT074()
{
  {
    init_simple_test("STT074");
    static STRUCT_IF_C STT074 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT074)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT074)");
    check_field_offset(lv, fa, 0, "STT074.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT074.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT074, STT074)
//============================================================================


struct  STT084  {
  char fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT084) C1{ Fc FL:3 FL}



static void Test_STT084()
{
  {
    init_simple_test("STT084");
    static STRUCT_IF_C STT084 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT084)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT084)");
    check_field_offset(lv, fa, 0, "STT084.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT084.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT084, STT084)
//============================================================================


struct  STT094  {
  char fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT094) C1{ Fc Fs:8 FL}



static void Test_STT094()
{
  {
    init_simple_test("STT094");
    static STRUCT_IF_C STT094 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT094)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT094)");
    check_field_offset(lv, fa, 0, "STT094.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT094.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT094, STT094)
//============================================================================


struct  STT0104  {
  char fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT0104) C1{ Fc Fi:8 FL}



static void Test_STT0104()
{
  {
    init_simple_test("STT0104");
    static STRUCT_IF_C STT0104 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0104)");
    check_field_offset(lv, fa, 0, "STT0104.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0104, STT0104)
//============================================================================


struct  STT0114  {
  char fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT0114) C1{ Fc FL:8 FL}



static void Test_STT0114()
{
  {
    init_simple_test("STT0114");
    static STRUCT_IF_C STT0114 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0114)");
    check_field_offset(lv, fa, 0, "STT0114.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0114, STT0114)
//============================================================================


struct  STT0124  {
  char fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT0124) C1{ Fc Fi:18 FL}



static void Test_STT0124()
{
  {
    init_simple_test("STT0124");
    static STRUCT_IF_C STT0124 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0124)");
    check_field_offset(lv, fa, 0, "STT0124.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0124, STT0124)
//============================================================================


struct  STT0134  {
  char fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT0134) C1{ Fc FL:18 FL}



static void Test_STT0134()
{
  {
    init_simple_test("STT0134");
    static STRUCT_IF_C STT0134 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0134)");
    check_field_offset(lv, fa, 0, "STT0134.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0134, STT0134)
//============================================================================


struct  STT0144  {
  char fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT0144) C1{ Fc FL:48 FL}



static void Test_STT0144()
{
  {
    init_simple_test("STT0144");
    static STRUCT_IF_C STT0144 lv;
    check2(sizeof(lv), 16, "sizeof(STT0144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0144)");
    check_field_offset(lv, fa, 0, "STT0144.fa");
    check_field_offset(lv, fb, 8, "STT0144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0144, STT0144)
//============================================================================


struct  STT0154  {
  char fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT0154) C1{ Fc Fc:3 FL}



static void Test_STT0154()
{
  {
    init_simple_test("STT0154");
    static STRUCT_IF_C STT0154 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0154)");
    check_field_offset(lv, fa, 0, "STT0154.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0154");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0154");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0154, STT0154)
//============================================================================


struct  STT0164  {
  char fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT0164) C1{ Fc Fs:3 FL}



static void Test_STT0164()
{
  {
    init_simple_test("STT0164");
    static STRUCT_IF_C STT0164 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0164)");
    check_field_offset(lv, fa, 0, "STT0164.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0164");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0164");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0164, STT0164)
//============================================================================


struct  STT0174  {
  char fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT0174) C1{ Fc Fi:3 FL}



static void Test_STT0174()
{
  {
    init_simple_test("STT0174");
    static STRUCT_IF_C STT0174 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0174)");
    check_field_offset(lv, fa, 0, "STT0174.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0174");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0174");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0174, STT0174)
//============================================================================


struct  STT0184  {
  char fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT0184) C1{ Fc FL:3 FL}



static void Test_STT0184()
{
  {
    init_simple_test("STT0184");
    static STRUCT_IF_C STT0184 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0184)");
    check_field_offset(lv, fa, 0, "STT0184.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0184");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0184");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0184, STT0184)
//============================================================================


struct  STT0194  {
  char fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT0194) C1{ Fc Fs:8 FL}



static void Test_STT0194()
{
  {
    init_simple_test("STT0194");
    static STRUCT_IF_C STT0194 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0194)");
    check_field_offset(lv, fa, 0, "STT0194.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0194");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0194");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0194, STT0194)
//============================================================================


struct  STT0204  {
  char fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT0204) C1{ Fc Fi:8 FL}



static void Test_STT0204()
{
  {
    init_simple_test("STT0204");
    static STRUCT_IF_C STT0204 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0204)");
    check_field_offset(lv, fa, 0, "STT0204.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0204");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0204");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0204, STT0204)
//============================================================================


struct  STT0214  {
  char fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT0214) C1{ Fc FL:8 FL}



static void Test_STT0214()
{
  {
    init_simple_test("STT0214");
    static STRUCT_IF_C STT0214 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0214)");
    check_field_offset(lv, fa, 0, "STT0214.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0214");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0214");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0214, STT0214)
//============================================================================


struct  STT0224  {
  char fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT0224) C1{ Fc Fi:18 FL}



static void Test_STT0224()
{
  {
    init_simple_test("STT0224");
    static STRUCT_IF_C STT0224 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0224)");
    check_field_offset(lv, fa, 0, "STT0224.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0224");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0224");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0224, STT0224)
//============================================================================


struct  STT0234  {
  char fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT0234) C1{ Fc FL:18 FL}



static void Test_STT0234()
{
  {
    init_simple_test("STT0234");
    static STRUCT_IF_C STT0234 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0234)");
    check_field_offset(lv, fa, 0, "STT0234.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0234");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0234");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0234, STT0234)
//============================================================================


struct  STT0244  {
  char fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT0244) C1{ Fc FL:48 FL}



static void Test_STT0244()
{
  {
    init_simple_test("STT0244");
    static STRUCT_IF_C STT0244 lv;
    check2(sizeof(lv), 16, "sizeof(STT0244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0244)");
    check_field_offset(lv, fa, 0, "STT0244.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0244");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0244");
    check_field_offset(lv, fb, 8, "STT0244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0244, STT0244)
//============================================================================


struct  STT015  {
  char fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT015) C1{ Fc Fc:0 Fp}



static void Test_STT015()
{
  {
    init_simple_test("STT015");
    static STRUCT_IF_C STT015 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT015)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT015)");
    check_field_offset(lv, fa, 0, "STT015.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT015.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT015, STT015)
//============================================================================


struct  STT025  {
  char fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT025) C1{ Fc Fs:0 Fp}



static void Test_STT025()
{
  {
    init_simple_test("STT025");
    static STRUCT_IF_C STT025 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT025)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT025)");
    check_field_offset(lv, fa, 0, "STT025.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT025.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT025, STT025)
//============================================================================


struct  STT035  {
  char fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT035) C1{ Fc Fi:0 Fp}



static void Test_STT035()
{
  {
    init_simple_test("STT035");
    static STRUCT_IF_C STT035 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT035)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT035)");
    check_field_offset(lv, fa, 0, "STT035.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT035.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT035, STT035)
//============================================================================


struct  STT045  {
  char fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT045) C1{ Fc FL:0 Fp}



static void Test_STT045()
{
  {
    init_simple_test("STT045");
    static STRUCT_IF_C STT045 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT045)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT045)");
    check_field_offset(lv, fa, 0, "STT045.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT045.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT045, STT045)
//============================================================================


struct  STT055  {
  char fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT055) C1{ Fc Fc:3 Fp}



static void Test_STT055()
{
  {
    init_simple_test("STT055");
    static STRUCT_IF_C STT055 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT055)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT055)");
    check_field_offset(lv, fa, 0, "STT055.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT055.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT055, STT055)
//============================================================================


struct  STT065  {
  char fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT065) C1{ Fc Fs:3 Fp}



static void Test_STT065()
{
  {
    init_simple_test("STT065");
    static STRUCT_IF_C STT065 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT065)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT065)");
    check_field_offset(lv, fa, 0, "STT065.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT065.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT065, STT065)
//============================================================================


struct  STT075  {
  char fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT075) C1{ Fc Fi:3 Fp}



static void Test_STT075()
{
  {
    init_simple_test("STT075");
    static STRUCT_IF_C STT075 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT075)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT075)");
    check_field_offset(lv, fa, 0, "STT075.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT075.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT075, STT075)
//============================================================================


struct  STT085  {
  char fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT085) C1{ Fc FL:3 Fp}



static void Test_STT085()
{
  {
    init_simple_test("STT085");
    static STRUCT_IF_C STT085 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT085)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT085)");
    check_field_offset(lv, fa, 0, "STT085.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT085.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT085, STT085)
//============================================================================


struct  STT095  {
  char fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT095) C1{ Fc Fs:8 Fp}



static void Test_STT095()
{
  {
    init_simple_test("STT095");
    static STRUCT_IF_C STT095 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT095)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT095)");
    check_field_offset(lv, fa, 0, "STT095.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT095.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT095, STT095)
//============================================================================


struct  STT0105  {
  char fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT0105) C1{ Fc Fi:8 Fp}



static void Test_STT0105()
{
  {
    init_simple_test("STT0105");
    static STRUCT_IF_C STT0105 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0105)");
    check_field_offset(lv, fa, 0, "STT0105.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0105, STT0105)
//============================================================================


struct  STT0115  {
  char fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT0115) C1{ Fc FL:8 Fp}



static void Test_STT0115()
{
  {
    init_simple_test("STT0115");
    static STRUCT_IF_C STT0115 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0115)");
    check_field_offset(lv, fa, 0, "STT0115.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0115, STT0115)
//============================================================================


struct  STT0125  {
  char fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT0125) C1{ Fc Fi:18 Fp}



static void Test_STT0125()
{
  {
    init_simple_test("STT0125");
    static STRUCT_IF_C STT0125 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0125)");
    check_field_offset(lv, fa, 0, "STT0125.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0125, STT0125)
//============================================================================


struct  STT0135  {
  char fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT0135) C1{ Fc FL:18 Fp}



static void Test_STT0135()
{
  {
    init_simple_test("STT0135");
    static STRUCT_IF_C STT0135 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0135)");
    check_field_offset(lv, fa, 0, "STT0135.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0135, STT0135)
//============================================================================


struct  STT0145  {
  char fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT0145) C1{ Fc FL:48 Fp}



static void Test_STT0145()
{
  {
    init_simple_test("STT0145");
    static STRUCT_IF_C STT0145 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0145)");
    check_field_offset(lv, fa, 0, "STT0145.fa");
    check_field_offset(lv, fb, 8, "STT0145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0145, STT0145)
//============================================================================


struct  STT0155  {
  char fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT0155) C1{ Fc Fc:3 Fp}



static void Test_STT0155()
{
  {
    init_simple_test("STT0155");
    static STRUCT_IF_C STT0155 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0155)");
    check_field_offset(lv, fa, 0, "STT0155.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0155");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0155");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0155, STT0155)
//============================================================================


struct  STT0165  {
  char fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT0165) C1{ Fc Fs:3 Fp}



static void Test_STT0165()
{
  {
    init_simple_test("STT0165");
    static STRUCT_IF_C STT0165 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0165)");
    check_field_offset(lv, fa, 0, "STT0165.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0165");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0165");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0165, STT0165)
//============================================================================


struct  STT0175  {
  char fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT0175) C1{ Fc Fi:3 Fp}



static void Test_STT0175()
{
  {
    init_simple_test("STT0175");
    static STRUCT_IF_C STT0175 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0175)");
    check_field_offset(lv, fa, 0, "STT0175.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0175");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0175");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0175, STT0175)
//============================================================================


struct  STT0185  {
  char fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT0185) C1{ Fc FL:3 Fp}



static void Test_STT0185()
{
  {
    init_simple_test("STT0185");
    static STRUCT_IF_C STT0185 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0185)");
    check_field_offset(lv, fa, 0, "STT0185.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0185");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0185");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0185, STT0185)
//============================================================================


struct  STT0195  {
  char fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT0195) C1{ Fc Fs:8 Fp}



static void Test_STT0195()
{
  {
    init_simple_test("STT0195");
    static STRUCT_IF_C STT0195 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0195)");
    check_field_offset(lv, fa, 0, "STT0195.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0195");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0195");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0195, STT0195)
//============================================================================


struct  STT0205  {
  char fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT0205) C1{ Fc Fi:8 Fp}



static void Test_STT0205()
{
  {
    init_simple_test("STT0205");
    static STRUCT_IF_C STT0205 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0205)");
    check_field_offset(lv, fa, 0, "STT0205.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0205");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0205");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0205, STT0205)
//============================================================================


struct  STT0215  {
  char fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT0215) C1{ Fc FL:8 Fp}



static void Test_STT0215()
{
  {
    init_simple_test("STT0215");
    static STRUCT_IF_C STT0215 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0215)");
    check_field_offset(lv, fa, 0, "STT0215.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0215");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0215");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0215, STT0215)
//============================================================================


struct  STT0225  {
  char fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT0225) C1{ Fc Fi:18 Fp}



static void Test_STT0225()
{
  {
    init_simple_test("STT0225");
    static STRUCT_IF_C STT0225 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0225)");
    check_field_offset(lv, fa, 0, "STT0225.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0225");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0225");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0225, STT0225)
//============================================================================


struct  STT0235  {
  char fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT0235) C1{ Fc FL:18 Fp}



static void Test_STT0235()
{
  {
    init_simple_test("STT0235");
    static STRUCT_IF_C STT0235 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT0235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0235)");
    check_field_offset(lv, fa, 0, "STT0235.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0235");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0235");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0235, STT0235)
//============================================================================


struct  STT0245  {
  char fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT0245) C1{ Fc FL:48 Fp}



static void Test_STT0245()
{
  {
    init_simple_test("STT0245");
    static STRUCT_IF_C STT0245 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0245)");
    check_field_offset(lv, fa, 0, "STT0245.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0245");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0245");
    check_field_offset(lv, fb, 8, "STT0245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0245, STT0245)
//============================================================================


struct  STT016  {
  char fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT016) C1{ Fc Fc:0 Fi}



static void Test_STT016()
{
  {
    init_simple_test("STT016");
    static STRUCT_IF_C STT016 lv;
    check2(sizeof(lv), 8, "sizeof(STT016)");
    check2(__alignof__(lv), 4, "__alignof__(STT016)");
    check_field_offset(lv, fa, 0, "STT016.fa");
    check_field_offset(lv, fb, 4, "STT016.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT016, STT016)
//============================================================================


struct  STT026  {
  char fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT026) C1{ Fc Fs:0 Fi}



static void Test_STT026()
{
  {
    init_simple_test("STT026");
    static STRUCT_IF_C STT026 lv;
    check2(sizeof(lv), 8, "sizeof(STT026)");
    check2(__alignof__(lv), 4, "__alignof__(STT026)");
    check_field_offset(lv, fa, 0, "STT026.fa");
    check_field_offset(lv, fb, 4, "STT026.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT026, STT026)
//============================================================================


struct  STT036  {
  char fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT036) C1{ Fc Fi:0 Fi}



static void Test_STT036()
{
  {
    init_simple_test("STT036");
    static STRUCT_IF_C STT036 lv;
    check2(sizeof(lv), 8, "sizeof(STT036)");
    check2(__alignof__(lv), 4, "__alignof__(STT036)");
    check_field_offset(lv, fa, 0, "STT036.fa");
    check_field_offset(lv, fb, 4, "STT036.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT036, STT036)
//============================================================================


struct  STT046  {
  char fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT046) C1{ Fc FL:0 Fi}



static void Test_STT046()
{
  {
    init_simple_test("STT046");
    static STRUCT_IF_C STT046 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT046)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT046)");
    check_field_offset(lv, fa, 0, "STT046.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT046.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT046, STT046)
//============================================================================


struct  STT056  {
  char fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT056) C1{ Fc Fc:3 Fi}



static void Test_STT056()
{
  {
    init_simple_test("STT056");
    static STRUCT_IF_C STT056 lv;
    check2(sizeof(lv), 8, "sizeof(STT056)");
    check2(__alignof__(lv), 4, "__alignof__(STT056)");
    check_field_offset(lv, fa, 0, "STT056.fa");
    check_field_offset(lv, fb, 4, "STT056.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT056, STT056)
//============================================================================


struct  STT066  {
  char fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT066) C1{ Fc Fs:3 Fi}



static void Test_STT066()
{
  {
    init_simple_test("STT066");
    static STRUCT_IF_C STT066 lv;
    check2(sizeof(lv), 8, "sizeof(STT066)");
    check2(__alignof__(lv), 4, "__alignof__(STT066)");
    check_field_offset(lv, fa, 0, "STT066.fa");
    check_field_offset(lv, fb, 4, "STT066.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT066, STT066)
//============================================================================


struct  STT076  {
  char fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT076) C1{ Fc Fi:3 Fi}



static void Test_STT076()
{
  {
    init_simple_test("STT076");
    static STRUCT_IF_C STT076 lv;
    check2(sizeof(lv), 8, "sizeof(STT076)");
    check2(__alignof__(lv), 4, "__alignof__(STT076)");
    check_field_offset(lv, fa, 0, "STT076.fa");
    check_field_offset(lv, fb, 4, "STT076.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT076, STT076)
//============================================================================


struct  STT086  {
  char fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT086) C1{ Fc FL:3 Fi}



static void Test_STT086()
{
  {
    init_simple_test("STT086");
    static STRUCT_IF_C STT086 lv;
    check2(sizeof(lv), 8, "sizeof(STT086)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT086)");
    check_field_offset(lv, fa, 0, "STT086.fa");
    check_field_offset(lv, fb, 4, "STT086.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT086, STT086)
//============================================================================


struct  STT096  {
  char fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT096) C1{ Fc Fs:8 Fi}



static void Test_STT096()
{
  {
    init_simple_test("STT096");
    static STRUCT_IF_C STT096 lv;
    check2(sizeof(lv), 8, "sizeof(STT096)");
    check2(__alignof__(lv), 4, "__alignof__(STT096)");
    check_field_offset(lv, fa, 0, "STT096.fa");
    check_field_offset(lv, fb, 4, "STT096.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT096, STT096)
//============================================================================


struct  STT0106  {
  char fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT0106) C1{ Fc Fi:8 Fi}



static void Test_STT0106()
{
  {
    init_simple_test("STT0106");
    static STRUCT_IF_C STT0106 lv;
    check2(sizeof(lv), 8, "sizeof(STT0106)");
    check2(__alignof__(lv), 4, "__alignof__(STT0106)");
    check_field_offset(lv, fa, 0, "STT0106.fa");
    check_field_offset(lv, fb, 4, "STT0106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0106, STT0106)
//============================================================================


struct  STT0116  {
  char fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT0116) C1{ Fc FL:8 Fi}



static void Test_STT0116()
{
  {
    init_simple_test("STT0116");
    static STRUCT_IF_C STT0116 lv;
    check2(sizeof(lv), 8, "sizeof(STT0116)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT0116)");
    check_field_offset(lv, fa, 0, "STT0116.fa");
    check_field_offset(lv, fb, 4, "STT0116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0116, STT0116)
//============================================================================


struct  STT0126  {
  char fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT0126) C1{ Fc Fi:18 Fi}



static void Test_STT0126()
{
  {
    init_simple_test("STT0126");
    static STRUCT_IF_C STT0126 lv;
    check2(sizeof(lv), 8, "sizeof(STT0126)");
    check2(__alignof__(lv), 4, "__alignof__(STT0126)");
    check_field_offset(lv, fa, 0, "STT0126.fa");
    check_field_offset(lv, fb, 4, "STT0126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0126, STT0126)
//============================================================================


struct  STT0136  {
  char fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT0136) C1{ Fc FL:18 Fi}



static void Test_STT0136()
{
  {
    init_simple_test("STT0136");
    static STRUCT_IF_C STT0136 lv;
    check2(sizeof(lv), 8, "sizeof(STT0136)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT0136)");
    check_field_offset(lv, fa, 0, "STT0136.fa");
    check_field_offset(lv, fb, 4, "STT0136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0136, STT0136)
//============================================================================


struct  STT0146  {
  char fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT0146) C1{ Fc FL:48 Fi}



static void Test_STT0146()
{
  {
    init_simple_test("STT0146");
    static STRUCT_IF_C STT0146 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT0146)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT0146)");
    check_field_offset(lv, fa, 0, "STT0146.fa");
    check_field_offset(lv, fb, 8, "STT0146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0146, STT0146)
//============================================================================


struct  STT0156  {
  char fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT0156) C1{ Fc Fc:3 Fi}



static void Test_STT0156()
{
  {
    init_simple_test("STT0156");
    static STRUCT_IF_C STT0156 lv;
    check2(sizeof(lv), 8, "sizeof(STT0156)");
    check2(__alignof__(lv), 4, "__alignof__(STT0156)");
    check_field_offset(lv, fa, 0, "STT0156.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0156");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0156");
    check_field_offset(lv, fb, 4, "STT0156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0156, STT0156)
//============================================================================


struct  STT0166  {
  char fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT0166) C1{ Fc Fs:3 Fi}



static void Test_STT0166()
{
  {
    init_simple_test("STT0166");
    static STRUCT_IF_C STT0166 lv;
    check2(sizeof(lv), 8, "sizeof(STT0166)");
    check2(__alignof__(lv), 4, "__alignof__(STT0166)");
    check_field_offset(lv, fa, 0, "STT0166.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0166");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0166");
    check_field_offset(lv, fb, 4, "STT0166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0166, STT0166)
//============================================================================


struct  STT0176  {
  char fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT0176) C1{ Fc Fi:3 Fi}



static void Test_STT0176()
{
  {
    init_simple_test("STT0176");
    static STRUCT_IF_C STT0176 lv;
    check2(sizeof(lv), 8, "sizeof(STT0176)");
    check2(__alignof__(lv), 4, "__alignof__(STT0176)");
    check_field_offset(lv, fa, 0, "STT0176.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0176");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0176");
    check_field_offset(lv, fb, 4, "STT0176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0176, STT0176)
//============================================================================


struct  STT0186  {
  char fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT0186) C1{ Fc FL:3 Fi}



static void Test_STT0186()
{
  {
    init_simple_test("STT0186");
    static STRUCT_IF_C STT0186 lv;
    check2(sizeof(lv), 8, "sizeof(STT0186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0186)");
    check_field_offset(lv, fa, 0, "STT0186.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0186");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0186");
    check_field_offset(lv, fb, 4, "STT0186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0186, STT0186)
//============================================================================


struct  STT0196  {
  char fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT0196) C1{ Fc Fs:8 Fi}



static void Test_STT0196()
{
  {
    init_simple_test("STT0196");
    static STRUCT_IF_C STT0196 lv;
    check2(sizeof(lv), 8, "sizeof(STT0196)");
    check2(__alignof__(lv), 4, "__alignof__(STT0196)");
    check_field_offset(lv, fa, 0, "STT0196.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0196");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0196");
    check_field_offset(lv, fb, 4, "STT0196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0196, STT0196)
//============================================================================


struct  STT0206  {
  char fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT0206) C1{ Fc Fi:8 Fi}



static void Test_STT0206()
{
  {
    init_simple_test("STT0206");
    static STRUCT_IF_C STT0206 lv;
    check2(sizeof(lv), 8, "sizeof(STT0206)");
    check2(__alignof__(lv), 4, "__alignof__(STT0206)");
    check_field_offset(lv, fa, 0, "STT0206.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0206");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0206");
    check_field_offset(lv, fb, 4, "STT0206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0206, STT0206)
//============================================================================


struct  STT0216  {
  char fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT0216) C1{ Fc FL:8 Fi}



static void Test_STT0216()
{
  {
    init_simple_test("STT0216");
    static STRUCT_IF_C STT0216 lv;
    check2(sizeof(lv), 8, "sizeof(STT0216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0216)");
    check_field_offset(lv, fa, 0, "STT0216.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0216");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0216");
    check_field_offset(lv, fb, 4, "STT0216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0216, STT0216)
//============================================================================


struct  STT0226  {
  char fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT0226) C1{ Fc Fi:18 Fi}



static void Test_STT0226()
{
  {
    init_simple_test("STT0226");
    static STRUCT_IF_C STT0226 lv;
    check2(sizeof(lv), 8, "sizeof(STT0226)");
    check2(__alignof__(lv), 4, "__alignof__(STT0226)");
    check_field_offset(lv, fa, 0, "STT0226.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0226");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0226");
    check_field_offset(lv, fb, 4, "STT0226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0226, STT0226)
//============================================================================


struct  STT0236  {
  char fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT0236) C1{ Fc FL:18 Fi}



static void Test_STT0236()
{
  {
    init_simple_test("STT0236");
    static STRUCT_IF_C STT0236 lv;
    check2(sizeof(lv), 8, "sizeof(STT0236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0236)");
    check_field_offset(lv, fa, 0, "STT0236.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0236");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0236");
    check_field_offset(lv, fb, 4, "STT0236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0236, STT0236)
//============================================================================


struct  STT0246  {
  char fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT0246) C1{ Fc FL:48 Fi}



static void Test_STT0246()
{
  {
    init_simple_test("STT0246");
    static STRUCT_IF_C STT0246 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0246)");
    check_field_offset(lv, fa, 0, "STT0246.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0246");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0246");
    check_field_offset(lv, fb, 8, "STT0246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0246, STT0246)
//============================================================================


struct  STT017  {
  char fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT017) C1{ Fc Fc:0 FL}



static void Test_STT017()
{
  {
    init_simple_test("STT017");
    static STRUCT_IF_C STT017 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT017)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT017)");
    check_field_offset(lv, fa, 0, "STT017.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT017.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT017, STT017)
//============================================================================


struct  STT027  {
  char fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT027) C1{ Fc Fs:0 FL}



static void Test_STT027()
{
  {
    init_simple_test("STT027");
    static STRUCT_IF_C STT027 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT027)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT027)");
    check_field_offset(lv, fa, 0, "STT027.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT027.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT027, STT027)
//============================================================================


struct  STT037  {
  char fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT037) C1{ Fc Fi:0 FL}



static void Test_STT037()
{
  {
    init_simple_test("STT037");
    static STRUCT_IF_C STT037 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT037)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT037)");
    check_field_offset(lv, fa, 0, "STT037.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT037.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT037, STT037)
//============================================================================


struct  STT047  {
  char fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT047) C1{ Fc FL:0 FL}



static void Test_STT047()
{
  {
    init_simple_test("STT047");
    static STRUCT_IF_C STT047 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT047)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT047)");
    check_field_offset(lv, fa, 0, "STT047.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT047.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT047, STT047)
//============================================================================


struct  STT057  {
  char fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT057) C1{ Fc Fc:3 FL}



static void Test_STT057()
{
  {
    init_simple_test("STT057");
    static STRUCT_IF_C STT057 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT057)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT057)");
    check_field_offset(lv, fa, 0, "STT057.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT057.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT057, STT057)
//============================================================================


struct  STT067  {
  char fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT067) C1{ Fc Fs:3 FL}



static void Test_STT067()
{
  {
    init_simple_test("STT067");
    static STRUCT_IF_C STT067 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT067)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT067)");
    check_field_offset(lv, fa, 0, "STT067.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT067.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT067, STT067)
//============================================================================


struct  STT077  {
  char fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT077) C1{ Fc Fi:3 FL}



static void Test_STT077()
{
  {
    init_simple_test("STT077");
    static STRUCT_IF_C STT077 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT077)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT077)");
    check_field_offset(lv, fa, 0, "STT077.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT077.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT077, STT077)
//============================================================================


struct  STT087  {
  char fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT087) C1{ Fc FL:3 FL}



static void Test_STT087()
{
  {
    init_simple_test("STT087");
    static STRUCT_IF_C STT087 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT087)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT087)");
    check_field_offset(lv, fa, 0, "STT087.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT087.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT087, STT087)
//============================================================================


struct  STT097  {
  char fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT097) C1{ Fc Fs:8 FL}



static void Test_STT097()
{
  {
    init_simple_test("STT097");
    static STRUCT_IF_C STT097 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT097)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT097)");
    check_field_offset(lv, fa, 0, "STT097.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT097.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT097, STT097)
//============================================================================


struct  STT0107  {
  char fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT0107) C1{ Fc Fi:8 FL}



static void Test_STT0107()
{
  {
    init_simple_test("STT0107");
    static STRUCT_IF_C STT0107 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0107)");
    check_field_offset(lv, fa, 0, "STT0107.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0107, STT0107)
//============================================================================


struct  STT0117  {
  char fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT0117) C1{ Fc FL:8 FL}



static void Test_STT0117()
{
  {
    init_simple_test("STT0117");
    static STRUCT_IF_C STT0117 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0117)");
    check_field_offset(lv, fa, 0, "STT0117.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0117, STT0117)
//============================================================================


struct  STT0127  {
  char fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT0127) C1{ Fc Fi:18 FL}



static void Test_STT0127()
{
  {
    init_simple_test("STT0127");
    static STRUCT_IF_C STT0127 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0127)");
    check_field_offset(lv, fa, 0, "STT0127.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0127, STT0127)
//============================================================================


struct  STT0137  {
  char fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT0137) C1{ Fc FL:18 FL}



static void Test_STT0137()
{
  {
    init_simple_test("STT0137");
    static STRUCT_IF_C STT0137 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0137)");
    check_field_offset(lv, fa, 0, "STT0137.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0137, STT0137)
//============================================================================


struct  STT0147  {
  char fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT0147) C1{ Fc FL:48 FL}



static void Test_STT0147()
{
  {
    init_simple_test("STT0147");
    static STRUCT_IF_C STT0147 lv;
    check2(sizeof(lv), 16, "sizeof(STT0147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0147)");
    check_field_offset(lv, fa, 0, "STT0147.fa");
    check_field_offset(lv, fb, 8, "STT0147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0147, STT0147)
//============================================================================


struct  STT0157  {
  char fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT0157) C1{ Fc Fc:3 FL}



static void Test_STT0157()
{
  {
    init_simple_test("STT0157");
    static STRUCT_IF_C STT0157 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0157)");
    check_field_offset(lv, fa, 0, "STT0157.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0157");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0157");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0157, STT0157)
//============================================================================


struct  STT0167  {
  char fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT0167) C1{ Fc Fs:3 FL}



static void Test_STT0167()
{
  {
    init_simple_test("STT0167");
    static STRUCT_IF_C STT0167 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0167)");
    check_field_offset(lv, fa, 0, "STT0167.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0167");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0167");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0167, STT0167)
//============================================================================


struct  STT0177  {
  char fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT0177) C1{ Fc Fi:3 FL}



static void Test_STT0177()
{
  {
    init_simple_test("STT0177");
    static STRUCT_IF_C STT0177 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0177)");
    check_field_offset(lv, fa, 0, "STT0177.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0177");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0177");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0177, STT0177)
//============================================================================


struct  STT0187  {
  char fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT0187) C1{ Fc FL:3 FL}



static void Test_STT0187()
{
  {
    init_simple_test("STT0187");
    static STRUCT_IF_C STT0187 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0187)");
    check_field_offset(lv, fa, 0, "STT0187.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0187");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0187");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0187, STT0187)
//============================================================================


struct  STT0197  {
  char fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT0197) C1{ Fc Fs:8 FL}



static void Test_STT0197()
{
  {
    init_simple_test("STT0197");
    static STRUCT_IF_C STT0197 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0197)");
    check_field_offset(lv, fa, 0, "STT0197.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0197");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0197");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0197, STT0197)
//============================================================================


struct  STT0207  {
  char fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT0207) C1{ Fc Fi:8 FL}



static void Test_STT0207()
{
  {
    init_simple_test("STT0207");
    static STRUCT_IF_C STT0207 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0207)");
    check_field_offset(lv, fa, 0, "STT0207.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0207");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0207");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0207, STT0207)
//============================================================================


struct  STT0217  {
  char fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT0217) C1{ Fc FL:8 FL}



static void Test_STT0217()
{
  {
    init_simple_test("STT0217");
    static STRUCT_IF_C STT0217 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0217)");
    check_field_offset(lv, fa, 0, "STT0217.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0217");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0217");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0217, STT0217)
//============================================================================


struct  STT0227  {
  char fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT0227) C1{ Fc Fi:18 FL}



static void Test_STT0227()
{
  {
    init_simple_test("STT0227");
    static STRUCT_IF_C STT0227 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0227)");
    check_field_offset(lv, fa, 0, "STT0227.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0227");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0227");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0227, STT0227)
//============================================================================


struct  STT0237  {
  char fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT0237) C1{ Fc FL:18 FL}



static void Test_STT0237()
{
  {
    init_simple_test("STT0237");
    static STRUCT_IF_C STT0237 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT0237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0237)");
    check_field_offset(lv, fa, 0, "STT0237.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0237");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0237");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT0237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0237, STT0237)
//============================================================================


struct  STT0247  {
  char fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT0247) C1{ Fc FL:48 FL}



static void Test_STT0247()
{
  {
    init_simple_test("STT0247");
    static STRUCT_IF_C STT0247 lv;
    check2(sizeof(lv), 16, "sizeof(STT0247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0247)");
    check_field_offset(lv, fa, 0, "STT0247.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0247");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0247");
    check_field_offset(lv, fb, 8, "STT0247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0247, STT0247)
//============================================================================


struct  STT018  {
  char fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT018) C1{ Fc Fc:0 FD}



static void Test_STT018()
{
  {
    init_simple_test("STT018");
    static STRUCT_IF_C STT018 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT018)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT018)");
    check_field_offset(lv, fa, 0, "STT018.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT018.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT018, STT018)
//============================================================================


struct  STT028  {
  char fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT028) C1{ Fc Fs:0 FD}



static void Test_STT028()
{
  {
    init_simple_test("STT028");
    static STRUCT_IF_C STT028 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT028)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT028)");
    check_field_offset(lv, fa, 0, "STT028.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT028.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT028, STT028)
//============================================================================


struct  STT038  {
  char fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT038) C1{ Fc Fi:0 FD}



static void Test_STT038()
{
  {
    init_simple_test("STT038");
    static STRUCT_IF_C STT038 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT038)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT038)");
    check_field_offset(lv, fa, 0, "STT038.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT038.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT038, STT038)
//============================================================================


struct  STT048  {
  char fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT048) C1{ Fc FL:0 FD}



static void Test_STT048()
{
  {
    init_simple_test("STT048");
    static STRUCT_IF_C STT048 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT048)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT048)");
    check_field_offset(lv, fa, 0, "STT048.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT048.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT048, STT048)
//============================================================================


struct  STT058  {
  char fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT058) C1{ Fc Fc:3 FD}



static void Test_STT058()
{
  {
    init_simple_test("STT058");
    static STRUCT_IF_C STT058 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT058)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT058)");
    check_field_offset(lv, fa, 0, "STT058.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT058.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT058, STT058)
//============================================================================


struct  STT068  {
  char fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT068) C1{ Fc Fs:3 FD}



static void Test_STT068()
{
  {
    init_simple_test("STT068");
    static STRUCT_IF_C STT068 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT068)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT068)");
    check_field_offset(lv, fa, 0, "STT068.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT068.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT068, STT068)
//============================================================================


struct  STT078  {
  char fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT078) C1{ Fc Fi:3 FD}



static void Test_STT078()
{
  {
    init_simple_test("STT078");
    static STRUCT_IF_C STT078 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT078)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT078)");
    check_field_offset(lv, fa, 0, "STT078.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT078.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT078, STT078)
//============================================================================


struct  STT088  {
  char fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT088) C1{ Fc FL:3 FD}



static void Test_STT088()
{
  {
    init_simple_test("STT088");
    static STRUCT_IF_C STT088 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT088)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT088)");
    check_field_offset(lv, fa, 0, "STT088.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT088.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT088, STT088)
//============================================================================


struct  STT098  {
  char fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT098) C1{ Fc Fs:8 FD}



static void Test_STT098()
{
  {
    init_simple_test("STT098");
    static STRUCT_IF_C STT098 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT098)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT098)");
    check_field_offset(lv, fa, 0, "STT098.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT098.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT098, STT098)
//============================================================================


struct  STT0108  {
  char fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT0108) C1{ Fc Fi:8 FD}



static void Test_STT0108()
{
  {
    init_simple_test("STT0108");
    static STRUCT_IF_C STT0108 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0108)");
    check_field_offset(lv, fa, 0, "STT0108.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0108, STT0108)
//============================================================================


struct  STT0118  {
  char fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT0118) C1{ Fc FL:8 FD}



static void Test_STT0118()
{
  {
    init_simple_test("STT0118");
    static STRUCT_IF_C STT0118 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0118)");
    check_field_offset(lv, fa, 0, "STT0118.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0118, STT0118)
//============================================================================


struct  STT0128  {
  char fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT0128) C1{ Fc Fi:18 FD}



static void Test_STT0128()
{
  {
    init_simple_test("STT0128");
    static STRUCT_IF_C STT0128 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0128)");
    check_field_offset(lv, fa, 0, "STT0128.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0128, STT0128)
//============================================================================


struct  STT0138  {
  char fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT0138) C1{ Fc FL:18 FD}



static void Test_STT0138()
{
  {
    init_simple_test("STT0138");
    static STRUCT_IF_C STT0138 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0138)");
    check_field_offset(lv, fa, 0, "STT0138.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0138, STT0138)
//============================================================================


struct  STT0148  {
  char fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT0148) C1{ Fc FL:48 FD}



static void Test_STT0148()
{
  {
    init_simple_test("STT0148");
    static STRUCT_IF_C STT0148 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT0148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0148)");
    check_field_offset(lv, fa, 0, "STT0148.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT0148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0148, STT0148)
//============================================================================


struct  STT0158  {
  char fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT0158) C1{ Fc Fc:3 FD}



static void Test_STT0158()
{
  {
    init_simple_test("STT0158");
    static STRUCT_IF_C STT0158 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0158)");
    check_field_offset(lv, fa, 0, "STT0158.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0158");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0158");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0158, STT0158)
//============================================================================


struct  STT0168  {
  char fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT0168) C1{ Fc Fs:3 FD}



static void Test_STT0168()
{
  {
    init_simple_test("STT0168");
    static STRUCT_IF_C STT0168 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0168)");
    check_field_offset(lv, fa, 0, "STT0168.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0168");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0168");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0168, STT0168)
//============================================================================


struct  STT0178  {
  char fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT0178) C1{ Fc Fi:3 FD}



static void Test_STT0178()
{
  {
    init_simple_test("STT0178");
    static STRUCT_IF_C STT0178 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0178)");
    check_field_offset(lv, fa, 0, "STT0178.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0178");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0178");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0178, STT0178)
//============================================================================


struct  STT0188  {
  char fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT0188) C1{ Fc FL:3 FD}



static void Test_STT0188()
{
  {
    init_simple_test("STT0188");
    static STRUCT_IF_C STT0188 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0188)");
    check_field_offset(lv, fa, 0, "STT0188.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0188");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0188");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0188, STT0188)
//============================================================================


struct  STT0198  {
  char fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT0198) C1{ Fc Fs:8 FD}



static void Test_STT0198()
{
  {
    init_simple_test("STT0198");
    static STRUCT_IF_C STT0198 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0198)");
    check_field_offset(lv, fa, 0, "STT0198.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0198");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0198");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0198, STT0198)
//============================================================================


struct  STT0208  {
  char fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT0208) C1{ Fc Fi:8 FD}



static void Test_STT0208()
{
  {
    init_simple_test("STT0208");
    static STRUCT_IF_C STT0208 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0208)");
    check_field_offset(lv, fa, 0, "STT0208.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0208");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0208");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0208, STT0208)
//============================================================================


struct  STT0218  {
  char fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT0218) C1{ Fc FL:8 FD}



static void Test_STT0218()
{
  {
    init_simple_test("STT0218");
    static STRUCT_IF_C STT0218 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0218)");
    check_field_offset(lv, fa, 0, "STT0218.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0218");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0218");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0218, STT0218)
//============================================================================


struct  STT0228  {
  char fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT0228) C1{ Fc Fi:18 FD}



static void Test_STT0228()
{
  {
    init_simple_test("STT0228");
    static STRUCT_IF_C STT0228 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0228)");
    check_field_offset(lv, fa, 0, "STT0228.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0228");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0228");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0228, STT0228)
//============================================================================


struct  STT0238  {
  char fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT0238) C1{ Fc FL:18 FD}



static void Test_STT0238()
{
  {
    init_simple_test("STT0238");
    static STRUCT_IF_C STT0238 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT0238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0238)");
    check_field_offset(lv, fa, 0, "STT0238.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0238");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0238");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT0238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0238, STT0238)
//============================================================================


struct  STT0248  {
  char fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT0248) C1{ Fc FL:48 FD}



static void Test_STT0248()
{
  {
    init_simple_test("STT0248");
    static STRUCT_IF_C STT0248 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT0248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT0248)");
    check_field_offset(lv, fa, 0, "STT0248.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0248");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0248");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT0248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0248, STT0248)
//============================================================================


struct  STT019  {
  char fa;
  unsigned char  :0;
};
//SIG(1 STT019) C1{ Fc Fc:0}



static void Test_STT019()
{
  {
    init_simple_test("STT019");
    static STRUCT_IF_C STT019 lv;
    check2(sizeof(lv), 1, "sizeof(STT019)");
    check2(__alignof__(lv), 1, "__alignof__(STT019)");
    check_field_offset(lv, fa, 0, "STT019.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT019, STT019)
//============================================================================


struct  STT029  {
  char fa;
  unsigned short  :0;
};
//SIG(1 STT029) C1{ Fc Fs:0}



static void Test_STT029()
{
  {
    init_simple_test("STT029");
    static STRUCT_IF_C STT029 lv;
    check2(sizeof(lv), 2, "sizeof(STT029)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT029)");
    check_field_offset(lv, fa, 0, "STT029.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT029, STT029)
//============================================================================


struct  STT039  {
  char fa;
  unsigned int  :0;
};
//SIG(1 STT039) C1{ Fc Fi:0}



static void Test_STT039()
{
  {
    init_simple_test("STT039");
    static STRUCT_IF_C STT039 lv;
    check2(sizeof(lv), 4, "sizeof(STT039)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT039)");
    check_field_offset(lv, fa, 0, "STT039.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT039, STT039)
//============================================================================


struct  STT049  {
  char fa;
  __tsu64  :0;
};
//SIG(1 STT049) C1{ Fc FL:0}



static void Test_STT049()
{
  {
    init_simple_test("STT049");
    static STRUCT_IF_C STT049 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT049)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT049)");
    check_field_offset(lv, fa, 0, "STT049.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT049, STT049)
//============================================================================


struct  STT059  {
  char fa;
  unsigned char  :3;
};
//SIG(1 STT059) C1{ Fc Fc:3}



static void Test_STT059()
{
  {
    init_simple_test("STT059");
    static STRUCT_IF_C STT059 lv;
    check2(sizeof(lv), 2, "sizeof(STT059)");
    check2(__alignof__(lv), 1, "__alignof__(STT059)");
    check_field_offset(lv, fa, 0, "STT059.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT059, STT059)
//============================================================================


struct  STT069  {
  char fa;
  unsigned short  :3;
};
//SIG(1 STT069) C1{ Fc Fs:3}



static void Test_STT069()
{
  {
    init_simple_test("STT069");
    static STRUCT_IF_C STT069 lv;
    check2(sizeof(lv), 2, "sizeof(STT069)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT069)");
    check_field_offset(lv, fa, 0, "STT069.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT069, STT069)
//============================================================================


struct  STT079  {
  char fa;
  unsigned int  :3;
};
//SIG(1 STT079) C1{ Fc Fi:3}



static void Test_STT079()
{
  {
    init_simple_test("STT079");
    static STRUCT_IF_C STT079 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT079)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT079)");
    check_field_offset(lv, fa, 0, "STT079.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT079, STT079)
//============================================================================


struct  STT089  {
  char fa;
  __tsu64  :3;
};
//SIG(1 STT089) C1{ Fc FL:3}



static void Test_STT089()
{
  {
    init_simple_test("STT089");
    static STRUCT_IF_C STT089 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT089)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT089)");
    check_field_offset(lv, fa, 0, "STT089.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT089, STT089)
//============================================================================


struct  STT099  {
  char fa;
  unsigned short  :8;
};
//SIG(1 STT099) C1{ Fc Fs:8}



static void Test_STT099()
{
  {
    init_simple_test("STT099");
    static STRUCT_IF_C STT099 lv;
    check2(sizeof(lv), 2, "sizeof(STT099)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT099)");
    check_field_offset(lv, fa, 0, "STT099.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT099, STT099)
//============================================================================


struct  STT0109  {
  char fa;
  unsigned int  :8;
};
//SIG(1 STT0109) C1{ Fc Fi:8}



static void Test_STT0109()
{
  {
    init_simple_test("STT0109");
    static STRUCT_IF_C STT0109 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT0109)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0109)");
    check_field_offset(lv, fa, 0, "STT0109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0109, STT0109)
//============================================================================


struct  STT0119  {
  char fa;
  __tsu64  :8;
};
//SIG(1 STT0119) C1{ Fc FL:8}



static void Test_STT0119()
{
  {
    init_simple_test("STT0119");
    static STRUCT_IF_C STT0119 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT0119)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0119)");
    check_field_offset(lv, fa, 0, "STT0119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0119, STT0119)
//============================================================================


struct  STT0129  {
  char fa;
  unsigned int  :18;
};
//SIG(1 STT0129) C1{ Fc Fi:18}



static void Test_STT0129()
{
  {
    init_simple_test("STT0129");
    static STRUCT_IF_C STT0129 lv;
    check2(sizeof(lv), 4, "sizeof(STT0129)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0129)");
    check_field_offset(lv, fa, 0, "STT0129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0129, STT0129)
//============================================================================


struct  STT0139  {
  char fa;
  __tsu64  :18;
};
//SIG(1 STT0139) C1{ Fc FL:18}



static void Test_STT0139()
{
  {
    init_simple_test("STT0139");
    static STRUCT_IF_C STT0139 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT0139)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0139)");
    check_field_offset(lv, fa, 0, "STT0139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0139, STT0139)
//============================================================================


struct  STT0149  {
  char fa;
  __tsu64  :48;
};
//SIG(1 STT0149) C1{ Fc FL:48}



static void Test_STT0149()
{
  {
    init_simple_test("STT0149");
    static STRUCT_IF_C STT0149 lv;
    check2(sizeof(lv), ABISELECT(7,7), "sizeof(STT0149)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT0149)");
    check_field_offset(lv, fa, 0, "STT0149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0149, STT0149)
//============================================================================


struct  STT0159  {
  char fa;
  unsigned char bf:3;
};
//SIG(1 STT0159) C1{ Fc Fc:3}



static void Test_STT0159()
{
  {
    init_simple_test("STT0159");
    static STRUCT_IF_C STT0159 lv;
    check2(sizeof(lv), 2, "sizeof(STT0159)");
    check2(__alignof__(lv), 1, "__alignof__(STT0159)");
    check_field_offset(lv, fa, 0, "STT0159.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0159");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0159, STT0159)
//============================================================================


struct  STT0169  {
  char fa;
  unsigned short bf:3;
};
//SIG(1 STT0169) C1{ Fc Fs:3}



static void Test_STT0169()
{
  {
    init_simple_test("STT0169");
    static STRUCT_IF_C STT0169 lv;
    check2(sizeof(lv), 2, "sizeof(STT0169)");
    check2(__alignof__(lv), 2, "__alignof__(STT0169)");
    check_field_offset(lv, fa, 0, "STT0169.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0169");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0169, STT0169)
//============================================================================


struct  STT0179  {
  char fa;
  unsigned int bf:3;
};
//SIG(1 STT0179) C1{ Fc Fi:3}



static void Test_STT0179()
{
  {
    init_simple_test("STT0179");
    static STRUCT_IF_C STT0179 lv;
    check2(sizeof(lv), 4, "sizeof(STT0179)");
    check2(__alignof__(lv), 4, "__alignof__(STT0179)");
    check_field_offset(lv, fa, 0, "STT0179.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0179");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0179, STT0179)
//============================================================================


struct  STT0189  {
  char fa;
  __tsu64 bf:3;
};
//SIG(1 STT0189) C1{ Fc FL:3}



static void Test_STT0189()
{
  {
    init_simple_test("STT0189");
    static STRUCT_IF_C STT0189 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0189)");
    check_field_offset(lv, fa, 0, "STT0189.fa");
    set_bf_and_test(lv, bf, 1, 0, 3, 1, "STT0189");
    set_bf_and_test(lv, bf, 1, 0, 3, hide_ull(1LL<<2), "STT0189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0189, STT0189)
//============================================================================


struct  STT0199  {
  char fa;
  unsigned short bf:8;
};
//SIG(1 STT0199) C1{ Fc Fs:8}



static void Test_STT0199()
{
  {
    init_simple_test("STT0199");
    static STRUCT_IF_C STT0199 lv;
    check2(sizeof(lv), 2, "sizeof(STT0199)");
    check2(__alignof__(lv), 2, "__alignof__(STT0199)");
    check_field_offset(lv, fa, 0, "STT0199.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0199");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0199, STT0199)
//============================================================================


struct  STT0209  {
  char fa;
  unsigned int bf:8;
};
//SIG(1 STT0209) C1{ Fc Fi:8}



static void Test_STT0209()
{
  {
    init_simple_test("STT0209");
    static STRUCT_IF_C STT0209 lv;
    check2(sizeof(lv), 4, "sizeof(STT0209)");
    check2(__alignof__(lv), 4, "__alignof__(STT0209)");
    check_field_offset(lv, fa, 0, "STT0209.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0209");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0209, STT0209)
//============================================================================


struct  STT0219  {
  char fa;
  __tsu64 bf:8;
};
//SIG(1 STT0219) C1{ Fc FL:8}



static void Test_STT0219()
{
  {
    init_simple_test("STT0219");
    static STRUCT_IF_C STT0219 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0219)");
    check_field_offset(lv, fa, 0, "STT0219.fa");
    set_bf_and_test(lv, bf, 1, 0, 8, 1, "STT0219");
    set_bf_and_test(lv, bf, 1, 0, 8, hide_ull(1LL<<7), "STT0219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0219, STT0219)
//============================================================================


struct  STT0229  {
  char fa;
  unsigned int bf:18;
};
//SIG(1 STT0229) C1{ Fc Fi:18}



static void Test_STT0229()
{
  {
    init_simple_test("STT0229");
    static STRUCT_IF_C STT0229 lv;
    check2(sizeof(lv), 4, "sizeof(STT0229)");
    check2(__alignof__(lv), 4, "__alignof__(STT0229)");
    check_field_offset(lv, fa, 0, "STT0229.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0229");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0229, STT0229)
//============================================================================


struct  STT0239  {
  char fa;
  __tsu64 bf:18;
};
//SIG(1 STT0239) C1{ Fc FL:18}



static void Test_STT0239()
{
  {
    init_simple_test("STT0239");
    static STRUCT_IF_C STT0239 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT0239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0239)");
    check_field_offset(lv, fa, 0, "STT0239.fa");
    set_bf_and_test(lv, bf, 1, 0, 18, 1, "STT0239");
    set_bf_and_test(lv, bf, 1, 0, 18, hide_ull(1LL<<17), "STT0239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0239, STT0239)
//============================================================================


struct  STT0249  {
  char fa;
  __tsu64 bf:48;
};
//SIG(1 STT0249) C1{ Fc FL:48}



static void Test_STT0249()
{
  {
    init_simple_test("STT0249");
    static STRUCT_IF_C STT0249 lv;
    check2(sizeof(lv), 8, "sizeof(STT0249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT0249)");
    check_field_offset(lv, fa, 0, "STT0249.fa");
    set_bf_and_test(lv, bf, 1, 0, 48, 1, "STT0249");
    set_bf_and_test(lv, bf, 1, 0, 48, hide_ull(1LL<<47), "STT0249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT0249, STT0249)
//============================================================================


struct  STT110  {
  short fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT110) C1{ Fs Fc:0 Fc}



static void Test_STT110()
{
  {
    init_simple_test("STT110");
    static STRUCT_IF_C STT110 lv;
    check2(sizeof(lv), 4, "sizeof(STT110)");
    check2(__alignof__(lv), 2, "__alignof__(STT110)");
    check_field_offset(lv, fa, 0, "STT110.fa");
    check_field_offset(lv, fb, 2, "STT110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT110, STT110)
//============================================================================


struct  STT120  {
  short fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT120) C1{ Fs Fs:0 Fc}



static void Test_STT120()
{
  {
    init_simple_test("STT120");
    static STRUCT_IF_C STT120 lv;
    check2(sizeof(lv), 4, "sizeof(STT120)");
    check2(__alignof__(lv), 2, "__alignof__(STT120)");
    check_field_offset(lv, fa, 0, "STT120.fa");
    check_field_offset(lv, fb, 2, "STT120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT120, STT120)
//============================================================================


struct  STT130  {
  short fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT130) C1{ Fs Fi:0 Fc}



static void Test_STT130()
{
  {
    init_simple_test("STT130");
    static STRUCT_IF_C STT130 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT130)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT130)");
    check_field_offset(lv, fa, 0, "STT130.fa");
    check_field_offset(lv, fb, 4, "STT130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT130, STT130)
//============================================================================


struct  STT140  {
  short fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT140) C1{ Fs FL:0 Fc}



static void Test_STT140()
{
  {
    init_simple_test("STT140");
    static STRUCT_IF_C STT140 lv;
    check2(sizeof(lv), ABISELECT(10,6), "sizeof(STT140)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT140)");
    check_field_offset(lv, fa, 0, "STT140.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT140, STT140)
//============================================================================


struct  STT150  {
  short fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT150) C1{ Fs Fc:3 Fc}



static void Test_STT150()
{
  {
    init_simple_test("STT150");
    static STRUCT_IF_C STT150 lv;
    check2(sizeof(lv), 4, "sizeof(STT150)");
    check2(__alignof__(lv), 2, "__alignof__(STT150)");
    check_field_offset(lv, fa, 0, "STT150.fa");
    check_field_offset(lv, fb, 3, "STT150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT150, STT150)
//============================================================================


struct  STT160  {
  short fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT160) C1{ Fs Fs:3 Fc}



static void Test_STT160()
{
  {
    init_simple_test("STT160");
    static STRUCT_IF_C STT160 lv;
    check2(sizeof(lv), 4, "sizeof(STT160)");
    check2(__alignof__(lv), 2, "__alignof__(STT160)");
    check_field_offset(lv, fa, 0, "STT160.fa");
    check_field_offset(lv, fb, 3, "STT160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT160, STT160)
//============================================================================


struct  STT170  {
  short fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT170) C1{ Fs Fi:3 Fc}



static void Test_STT170()
{
  {
    init_simple_test("STT170");
    static STRUCT_IF_C STT170 lv;
    check2(sizeof(lv), 4, "sizeof(STT170)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT170)");
    check_field_offset(lv, fa, 0, "STT170.fa");
    check_field_offset(lv, fb, 3, "STT170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT170, STT170)
//============================================================================


struct  STT180  {
  short fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT180) C1{ Fs FL:3 Fc}



static void Test_STT180()
{
  {
    init_simple_test("STT180");
    static STRUCT_IF_C STT180 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT180)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT180)");
    check_field_offset(lv, fa, 0, "STT180.fa");
    check_field_offset(lv, fb, 3, "STT180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT180, STT180)
//============================================================================


struct  STT190  {
  short fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT190) C1{ Fs Fs:8 Fc}



static void Test_STT190()
{
  {
    init_simple_test("STT190");
    static STRUCT_IF_C STT190 lv;
    check2(sizeof(lv), 4, "sizeof(STT190)");
    check2(__alignof__(lv), 2, "__alignof__(STT190)");
    check_field_offset(lv, fa, 0, "STT190.fa");
    check_field_offset(lv, fb, 3, "STT190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT190, STT190)
//============================================================================


struct  STT1100  {
  short fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT1100) C1{ Fs Fi:8 Fc}



static void Test_STT1100()
{
  {
    init_simple_test("STT1100");
    static STRUCT_IF_C STT1100 lv;
    check2(sizeof(lv), 4, "sizeof(STT1100)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1100)");
    check_field_offset(lv, fa, 0, "STT1100.fa");
    check_field_offset(lv, fb, 3, "STT1100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1100, STT1100)
//============================================================================


struct  STT1110  {
  short fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT1110) C1{ Fs FL:8 Fc}



static void Test_STT1110()
{
  {
    init_simple_test("STT1110");
    static STRUCT_IF_C STT1110 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT1110)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1110)");
    check_field_offset(lv, fa, 0, "STT1110.fa");
    check_field_offset(lv, fb, 3, "STT1110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1110, STT1110)
//============================================================================


struct  STT1120  {
  short fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT1120) C1{ Fs Fi:18 Fc}



static void Test_STT1120()
{
  {
    init_simple_test("STT1120");
    static STRUCT_IF_C STT1120 lv;
    check2(sizeof(lv), 8, "sizeof(STT1120)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1120)");
    check_field_offset(lv, fa, 0, "STT1120.fa");
    check_field_offset(lv, fb, 7, "STT1120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1120, STT1120)
//============================================================================


struct  STT1130  {
  short fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT1130) C1{ Fs FL:18 Fc}



static void Test_STT1130()
{
  {
    init_simple_test("STT1130");
    static STRUCT_IF_C STT1130 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT1130)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1130)");
    check_field_offset(lv, fa, 0, "STT1130.fa");
    check_field_offset(lv, fb, 5, "STT1130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1130, STT1130)
//============================================================================


struct  STT1140  {
  short fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT1140) C1{ Fs FL:48 Fc}



static void Test_STT1140()
{
  {
    init_simple_test("STT1140");
    static STRUCT_IF_C STT1140 lv;
    check2(sizeof(lv), ABISELECT(10,10), "sizeof(STT1140)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1140)");
    check_field_offset(lv, fa, 0, "STT1140.fa");
    check_field_offset(lv, fb, 8, "STT1140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1140, STT1140)
//============================================================================


struct  STT1150  {
  short fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT1150) C1{ Fs Fc:3 Fc}



static void Test_STT1150()
{
  {
    init_simple_test("STT1150");
    static STRUCT_IF_C STT1150 lv;
    check2(sizeof(lv), 4, "sizeof(STT1150)");
    check2(__alignof__(lv), 2, "__alignof__(STT1150)");
    check_field_offset(lv, fa, 0, "STT1150.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1150");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1150");
    check_field_offset(lv, fb, 3, "STT1150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1150, STT1150)
//============================================================================


struct  STT1160  {
  short fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT1160) C1{ Fs Fs:3 Fc}



static void Test_STT1160()
{
  {
    init_simple_test("STT1160");
    static STRUCT_IF_C STT1160 lv;
    check2(sizeof(lv), 4, "sizeof(STT1160)");
    check2(__alignof__(lv), 2, "__alignof__(STT1160)");
    check_field_offset(lv, fa, 0, "STT1160.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1160");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1160");
    check_field_offset(lv, fb, 3, "STT1160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1160, STT1160)
//============================================================================


struct  STT1170  {
  short fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT1170) C1{ Fs Fi:3 Fc}



static void Test_STT1170()
{
  {
    init_simple_test("STT1170");
    static STRUCT_IF_C STT1170 lv;
    check2(sizeof(lv), 4, "sizeof(STT1170)");
    check2(__alignof__(lv), 4, "__alignof__(STT1170)");
    check_field_offset(lv, fa, 0, "STT1170.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1170");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1170");
    check_field_offset(lv, fb, 3, "STT1170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1170, STT1170)
//============================================================================


struct  STT1180  {
  short fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT1180) C1{ Fs FL:3 Fc}



static void Test_STT1180()
{
  {
    init_simple_test("STT1180");
    static STRUCT_IF_C STT1180 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT1180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1180)");
    check_field_offset(lv, fa, 0, "STT1180.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1180");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1180");
    check_field_offset(lv, fb, 3, "STT1180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1180, STT1180)
//============================================================================


struct  STT1190  {
  short fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT1190) C1{ Fs Fs:8 Fc}



static void Test_STT1190()
{
  {
    init_simple_test("STT1190");
    static STRUCT_IF_C STT1190 lv;
    check2(sizeof(lv), 4, "sizeof(STT1190)");
    check2(__alignof__(lv), 2, "__alignof__(STT1190)");
    check_field_offset(lv, fa, 0, "STT1190.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1190");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1190");
    check_field_offset(lv, fb, 3, "STT1190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1190, STT1190)
//============================================================================


struct  STT1200  {
  short fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT1200) C1{ Fs Fi:8 Fc}



static void Test_STT1200()
{
  {
    init_simple_test("STT1200");
    static STRUCT_IF_C STT1200 lv;
    check2(sizeof(lv), 4, "sizeof(STT1200)");
    check2(__alignof__(lv), 4, "__alignof__(STT1200)");
    check_field_offset(lv, fa, 0, "STT1200.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1200");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1200");
    check_field_offset(lv, fb, 3, "STT1200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1200, STT1200)
//============================================================================


struct  STT1210  {
  short fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT1210) C1{ Fs FL:8 Fc}



static void Test_STT1210()
{
  {
    init_simple_test("STT1210");
    static STRUCT_IF_C STT1210 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT1210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1210)");
    check_field_offset(lv, fa, 0, "STT1210.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1210");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1210");
    check_field_offset(lv, fb, 3, "STT1210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1210, STT1210)
//============================================================================


struct  STT1220  {
  short fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT1220) C1{ Fs Fi:18 Fc}



static void Test_STT1220()
{
  {
    init_simple_test("STT1220");
    static STRUCT_IF_C STT1220 lv;
    check2(sizeof(lv), 8, "sizeof(STT1220)");
    check2(__alignof__(lv), 4, "__alignof__(STT1220)");
    check_field_offset(lv, fa, 0, "STT1220.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1220");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1220");
    check_field_offset(lv, fb, 7, "STT1220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1220, STT1220)
//============================================================================


struct  STT1230  {
  short fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT1230) C1{ Fs FL:18 Fc}



static void Test_STT1230()
{
  {
    init_simple_test("STT1230");
    static STRUCT_IF_C STT1230 lv;
    check2(sizeof(lv), 8, "sizeof(STT1230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1230)");
    check_field_offset(lv, fa, 0, "STT1230.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1230");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1230");
    check_field_offset(lv, fb, 5, "STT1230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1230, STT1230)
//============================================================================


struct  STT1240  {
  short fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT1240) C1{ Fs FL:48 Fc}



static void Test_STT1240()
{
  {
    init_simple_test("STT1240");
    static STRUCT_IF_C STT1240 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1240)");
    check_field_offset(lv, fa, 0, "STT1240.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1240");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1240");
    check_field_offset(lv, fb, 8, "STT1240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1240, STT1240)
//============================================================================


struct  STT111  {
  short fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT111) C1{ Fs Fc:0 Fs}



static void Test_STT111()
{
  {
    init_simple_test("STT111");
    static STRUCT_IF_C STT111 lv;
    check2(sizeof(lv), 4, "sizeof(STT111)");
    check2(__alignof__(lv), 2, "__alignof__(STT111)");
    check_field_offset(lv, fa, 0, "STT111.fa");
    check_field_offset(lv, fb, 2, "STT111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT111, STT111)
//============================================================================


struct  STT121  {
  short fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT121) C1{ Fs Fs:0 Fs}



static void Test_STT121()
{
  {
    init_simple_test("STT121");
    static STRUCT_IF_C STT121 lv;
    check2(sizeof(lv), 4, "sizeof(STT121)");
    check2(__alignof__(lv), 2, "__alignof__(STT121)");
    check_field_offset(lv, fa, 0, "STT121.fa");
    check_field_offset(lv, fb, 2, "STT121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT121, STT121)
//============================================================================


struct  STT131  {
  short fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT131) C1{ Fs Fi:0 Fs}



static void Test_STT131()
{
  {
    init_simple_test("STT131");
    static STRUCT_IF_C STT131 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT131)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT131)");
    check_field_offset(lv, fa, 0, "STT131.fa");
    check_field_offset(lv, fb, 4, "STT131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT131, STT131)
//============================================================================


struct  STT141  {
  short fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT141) C1{ Fs FL:0 Fs}



static void Test_STT141()
{
  {
    init_simple_test("STT141");
    static STRUCT_IF_C STT141 lv;
    check2(sizeof(lv), ABISELECT(10,6), "sizeof(STT141)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT141)");
    check_field_offset(lv, fa, 0, "STT141.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT141, STT141)
//============================================================================


struct  STT151  {
  short fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT151) C1{ Fs Fc:3 Fs}



static void Test_STT151()
{
  {
    init_simple_test("STT151");
    static STRUCT_IF_C STT151 lv;
    check2(sizeof(lv), 6, "sizeof(STT151)");
    check2(__alignof__(lv), 2, "__alignof__(STT151)");
    check_field_offset(lv, fa, 0, "STT151.fa");
    check_field_offset(lv, fb, 4, "STT151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT151, STT151)
//============================================================================


struct  STT161  {
  short fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT161) C1{ Fs Fs:3 Fs}



static void Test_STT161()
{
  {
    init_simple_test("STT161");
    static STRUCT_IF_C STT161 lv;
    check2(sizeof(lv), 6, "sizeof(STT161)");
    check2(__alignof__(lv), 2, "__alignof__(STT161)");
    check_field_offset(lv, fa, 0, "STT161.fa");
    check_field_offset(lv, fb, 4, "STT161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT161, STT161)
//============================================================================


struct  STT171  {
  short fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT171) C1{ Fs Fi:3 Fs}



static void Test_STT171()
{
  {
    init_simple_test("STT171");
    static STRUCT_IF_C STT171 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT171)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT171)");
    check_field_offset(lv, fa, 0, "STT171.fa");
    check_field_offset(lv, fb, 4, "STT171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT171, STT171)
//============================================================================


struct  STT181  {
  short fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT181) C1{ Fs FL:3 Fs}



static void Test_STT181()
{
  {
    init_simple_test("STT181");
    static STRUCT_IF_C STT181 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT181)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT181)");
    check_field_offset(lv, fa, 0, "STT181.fa");
    check_field_offset(lv, fb, 4, "STT181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT181, STT181)
//============================================================================


struct  STT191  {
  short fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT191) C1{ Fs Fs:8 Fs}



static void Test_STT191()
{
  {
    init_simple_test("STT191");
    static STRUCT_IF_C STT191 lv;
    check2(sizeof(lv), 6, "sizeof(STT191)");
    check2(__alignof__(lv), 2, "__alignof__(STT191)");
    check_field_offset(lv, fa, 0, "STT191.fa");
    check_field_offset(lv, fb, 4, "STT191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT191, STT191)
//============================================================================


struct  STT1101  {
  short fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT1101) C1{ Fs Fi:8 Fs}



static void Test_STT1101()
{
  {
    init_simple_test("STT1101");
    static STRUCT_IF_C STT1101 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT1101)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1101)");
    check_field_offset(lv, fa, 0, "STT1101.fa");
    check_field_offset(lv, fb, 4, "STT1101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1101, STT1101)
//============================================================================


struct  STT1111  {
  short fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT1111) C1{ Fs FL:8 Fs}



static void Test_STT1111()
{
  {
    init_simple_test("STT1111");
    static STRUCT_IF_C STT1111 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT1111)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1111)");
    check_field_offset(lv, fa, 0, "STT1111.fa");
    check_field_offset(lv, fb, 4, "STT1111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1111, STT1111)
//============================================================================


struct  STT1121  {
  short fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT1121) C1{ Fs Fi:18 Fs}



static void Test_STT1121()
{
  {
    init_simple_test("STT1121");
    static STRUCT_IF_C STT1121 lv;
    check2(sizeof(lv), ABISELECT(10,10), "sizeof(STT1121)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1121)");
    check_field_offset(lv, fa, 0, "STT1121.fa");
    check_field_offset(lv, fb, 8, "STT1121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1121, STT1121)
//============================================================================


struct  STT1131  {
  short fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT1131) C1{ Fs FL:18 Fs}



static void Test_STT1131()
{
  {
    init_simple_test("STT1131");
    static STRUCT_IF_C STT1131 lv;
    check2(sizeof(lv), 8, "sizeof(STT1131)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1131)");
    check_field_offset(lv, fa, 0, "STT1131.fa");
    check_field_offset(lv, fb, 6, "STT1131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1131, STT1131)
//============================================================================


struct  STT1141  {
  short fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT1141) C1{ Fs FL:48 Fs}



static void Test_STT1141()
{
  {
    init_simple_test("STT1141");
    static STRUCT_IF_C STT1141 lv;
    check2(sizeof(lv), ABISELECT(10,10), "sizeof(STT1141)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1141)");
    check_field_offset(lv, fa, 0, "STT1141.fa");
    check_field_offset(lv, fb, 8, "STT1141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1141, STT1141)
//============================================================================


struct  STT1151  {
  short fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT1151) C1{ Fs Fc:3 Fs}



static void Test_STT1151()
{
  {
    init_simple_test("STT1151");
    static STRUCT_IF_C STT1151 lv;
    check2(sizeof(lv), 6, "sizeof(STT1151)");
    check2(__alignof__(lv), 2, "__alignof__(STT1151)");
    check_field_offset(lv, fa, 0, "STT1151.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1151");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1151");
    check_field_offset(lv, fb, 4, "STT1151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1151, STT1151)
//============================================================================


struct  STT1161  {
  short fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT1161) C1{ Fs Fs:3 Fs}



static void Test_STT1161()
{
  {
    init_simple_test("STT1161");
    static STRUCT_IF_C STT1161 lv;
    check2(sizeof(lv), 6, "sizeof(STT1161)");
    check2(__alignof__(lv), 2, "__alignof__(STT1161)");
    check_field_offset(lv, fa, 0, "STT1161.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1161");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1161");
    check_field_offset(lv, fb, 4, "STT1161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1161, STT1161)
//============================================================================


struct  STT1171  {
  short fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT1171) C1{ Fs Fi:3 Fs}



static void Test_STT1171()
{
  {
    init_simple_test("STT1171");
    static STRUCT_IF_C STT1171 lv;
    check2(sizeof(lv), 8, "sizeof(STT1171)");
    check2(__alignof__(lv), 4, "__alignof__(STT1171)");
    check_field_offset(lv, fa, 0, "STT1171.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1171");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1171");
    check_field_offset(lv, fb, 4, "STT1171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1171, STT1171)
//============================================================================


struct  STT1181  {
  short fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT1181) C1{ Fs FL:3 Fs}



static void Test_STT1181()
{
  {
    init_simple_test("STT1181");
    static STRUCT_IF_C STT1181 lv;
    check2(sizeof(lv), 8, "sizeof(STT1181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1181)");
    check_field_offset(lv, fa, 0, "STT1181.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1181");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1181");
    check_field_offset(lv, fb, 4, "STT1181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1181, STT1181)
//============================================================================


struct  STT1191  {
  short fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT1191) C1{ Fs Fs:8 Fs}



static void Test_STT1191()
{
  {
    init_simple_test("STT1191");
    static STRUCT_IF_C STT1191 lv;
    check2(sizeof(lv), 6, "sizeof(STT1191)");
    check2(__alignof__(lv), 2, "__alignof__(STT1191)");
    check_field_offset(lv, fa, 0, "STT1191.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1191");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1191");
    check_field_offset(lv, fb, 4, "STT1191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1191, STT1191)
//============================================================================


struct  STT1201  {
  short fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT1201) C1{ Fs Fi:8 Fs}



static void Test_STT1201()
{
  {
    init_simple_test("STT1201");
    static STRUCT_IF_C STT1201 lv;
    check2(sizeof(lv), 8, "sizeof(STT1201)");
    check2(__alignof__(lv), 4, "__alignof__(STT1201)");
    check_field_offset(lv, fa, 0, "STT1201.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1201");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1201");
    check_field_offset(lv, fb, 4, "STT1201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1201, STT1201)
//============================================================================


struct  STT1211  {
  short fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT1211) C1{ Fs FL:8 Fs}



static void Test_STT1211()
{
  {
    init_simple_test("STT1211");
    static STRUCT_IF_C STT1211 lv;
    check2(sizeof(lv), 8, "sizeof(STT1211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1211)");
    check_field_offset(lv, fa, 0, "STT1211.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1211");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1211");
    check_field_offset(lv, fb, 4, "STT1211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1211, STT1211)
//============================================================================


struct  STT1221  {
  short fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT1221) C1{ Fs Fi:18 Fs}



static void Test_STT1221()
{
  {
    init_simple_test("STT1221");
    static STRUCT_IF_C STT1221 lv;
    check2(sizeof(lv), 12, "sizeof(STT1221)");
    check2(__alignof__(lv), 4, "__alignof__(STT1221)");
    check_field_offset(lv, fa, 0, "STT1221.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1221");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1221");
    check_field_offset(lv, fb, 8, "STT1221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1221, STT1221)
//============================================================================


struct  STT1231  {
  short fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT1231) C1{ Fs FL:18 Fs}



static void Test_STT1231()
{
  {
    init_simple_test("STT1231");
    static STRUCT_IF_C STT1231 lv;
    check2(sizeof(lv), 8, "sizeof(STT1231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1231)");
    check_field_offset(lv, fa, 0, "STT1231.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1231");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1231");
    check_field_offset(lv, fb, 6, "STT1231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1231, STT1231)
//============================================================================


struct  STT1241  {
  short fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT1241) C1{ Fs FL:48 Fs}



static void Test_STT1241()
{
  {
    init_simple_test("STT1241");
    static STRUCT_IF_C STT1241 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1241)");
    check_field_offset(lv, fa, 0, "STT1241.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1241");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1241");
    check_field_offset(lv, fb, 8, "STT1241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1241, STT1241)
//============================================================================


struct  STT112  {
  short fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT112) C1{ Fs Fc:0 Fi}



static void Test_STT112()
{
  {
    init_simple_test("STT112");
    static STRUCT_IF_C STT112 lv;
    check2(sizeof(lv), 8, "sizeof(STT112)");
    check2(__alignof__(lv), 4, "__alignof__(STT112)");
    check_field_offset(lv, fa, 0, "STT112.fa");
    check_field_offset(lv, fb, 4, "STT112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT112, STT112)
//============================================================================


struct  STT122  {
  short fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT122) C1{ Fs Fs:0 Fi}



static void Test_STT122()
{
  {
    init_simple_test("STT122");
    static STRUCT_IF_C STT122 lv;
    check2(sizeof(lv), 8, "sizeof(STT122)");
    check2(__alignof__(lv), 4, "__alignof__(STT122)");
    check_field_offset(lv, fa, 0, "STT122.fa");
    check_field_offset(lv, fb, 4, "STT122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT122, STT122)
//============================================================================


struct  STT132  {
  short fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT132) C1{ Fs Fi:0 Fi}



static void Test_STT132()
{
  {
    init_simple_test("STT132");
    static STRUCT_IF_C STT132 lv;
    check2(sizeof(lv), 8, "sizeof(STT132)");
    check2(__alignof__(lv), 4, "__alignof__(STT132)");
    check_field_offset(lv, fa, 0, "STT132.fa");
    check_field_offset(lv, fb, 4, "STT132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT132, STT132)
//============================================================================


struct  STT142  {
  short fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT142) C1{ Fs FL:0 Fi}



static void Test_STT142()
{
  {
    init_simple_test("STT142");
    static STRUCT_IF_C STT142 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT142)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT142)");
    check_field_offset(lv, fa, 0, "STT142.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT142, STT142)
//============================================================================


struct  STT152  {
  short fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT152) C1{ Fs Fc:3 Fi}



static void Test_STT152()
{
  {
    init_simple_test("STT152");
    static STRUCT_IF_C STT152 lv;
    check2(sizeof(lv), 8, "sizeof(STT152)");
    check2(__alignof__(lv), 4, "__alignof__(STT152)");
    check_field_offset(lv, fa, 0, "STT152.fa");
    check_field_offset(lv, fb, 4, "STT152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT152, STT152)
//============================================================================


struct  STT162  {
  short fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT162) C1{ Fs Fs:3 Fi}



static void Test_STT162()
{
  {
    init_simple_test("STT162");
    static STRUCT_IF_C STT162 lv;
    check2(sizeof(lv), 8, "sizeof(STT162)");
    check2(__alignof__(lv), 4, "__alignof__(STT162)");
    check_field_offset(lv, fa, 0, "STT162.fa");
    check_field_offset(lv, fb, 4, "STT162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT162, STT162)
//============================================================================


struct  STT172  {
  short fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT172) C1{ Fs Fi:3 Fi}



static void Test_STT172()
{
  {
    init_simple_test("STT172");
    static STRUCT_IF_C STT172 lv;
    check2(sizeof(lv), 8, "sizeof(STT172)");
    check2(__alignof__(lv), 4, "__alignof__(STT172)");
    check_field_offset(lv, fa, 0, "STT172.fa");
    check_field_offset(lv, fb, 4, "STT172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT172, STT172)
//============================================================================


struct  STT182  {
  short fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT182) C1{ Fs FL:3 Fi}



static void Test_STT182()
{
  {
    init_simple_test("STT182");
    static STRUCT_IF_C STT182 lv;
    check2(sizeof(lv), 8, "sizeof(STT182)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT182)");
    check_field_offset(lv, fa, 0, "STT182.fa");
    check_field_offset(lv, fb, 4, "STT182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT182, STT182)
//============================================================================


struct  STT192  {
  short fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT192) C1{ Fs Fs:8 Fi}



static void Test_STT192()
{
  {
    init_simple_test("STT192");
    static STRUCT_IF_C STT192 lv;
    check2(sizeof(lv), 8, "sizeof(STT192)");
    check2(__alignof__(lv), 4, "__alignof__(STT192)");
    check_field_offset(lv, fa, 0, "STT192.fa");
    check_field_offset(lv, fb, 4, "STT192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT192, STT192)
//============================================================================


struct  STT1102  {
  short fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT1102) C1{ Fs Fi:8 Fi}



static void Test_STT1102()
{
  {
    init_simple_test("STT1102");
    static STRUCT_IF_C STT1102 lv;
    check2(sizeof(lv), 8, "sizeof(STT1102)");
    check2(__alignof__(lv), 4, "__alignof__(STT1102)");
    check_field_offset(lv, fa, 0, "STT1102.fa");
    check_field_offset(lv, fb, 4, "STT1102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1102, STT1102)
//============================================================================


struct  STT1112  {
  short fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT1112) C1{ Fs FL:8 Fi}



static void Test_STT1112()
{
  {
    init_simple_test("STT1112");
    static STRUCT_IF_C STT1112 lv;
    check2(sizeof(lv), 8, "sizeof(STT1112)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT1112)");
    check_field_offset(lv, fa, 0, "STT1112.fa");
    check_field_offset(lv, fb, 4, "STT1112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1112, STT1112)
//============================================================================


struct  STT1122  {
  short fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT1122) C1{ Fs Fi:18 Fi}



static void Test_STT1122()
{
  {
    init_simple_test("STT1122");
    static STRUCT_IF_C STT1122 lv;
    check2(sizeof(lv), 12, "sizeof(STT1122)");
    check2(__alignof__(lv), 4, "__alignof__(STT1122)");
    check_field_offset(lv, fa, 0, "STT1122.fa");
    check_field_offset(lv, fb, 8, "STT1122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1122, STT1122)
//============================================================================


struct  STT1132  {
  short fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT1132) C1{ Fs FL:18 Fi}



static void Test_STT1132()
{
  {
    init_simple_test("STT1132");
    static STRUCT_IF_C STT1132 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT1132)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT1132)");
    check_field_offset(lv, fa, 0, "STT1132.fa");
    check_field_offset(lv, fb, 8, "STT1132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1132, STT1132)
//============================================================================


struct  STT1142  {
  short fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT1142) C1{ Fs FL:48 Fi}



static void Test_STT1142()
{
  {
    init_simple_test("STT1142");
    static STRUCT_IF_C STT1142 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT1142)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT1142)");
    check_field_offset(lv, fa, 0, "STT1142.fa");
    check_field_offset(lv, fb, 8, "STT1142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1142, STT1142)
//============================================================================


struct  STT1152  {
  short fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT1152) C1{ Fs Fc:3 Fi}



static void Test_STT1152()
{
  {
    init_simple_test("STT1152");
    static STRUCT_IF_C STT1152 lv;
    check2(sizeof(lv), 8, "sizeof(STT1152)");
    check2(__alignof__(lv), 4, "__alignof__(STT1152)");
    check_field_offset(lv, fa, 0, "STT1152.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1152");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1152");
    check_field_offset(lv, fb, 4, "STT1152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1152, STT1152)
//============================================================================


struct  STT1162  {
  short fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT1162) C1{ Fs Fs:3 Fi}



static void Test_STT1162()
{
  {
    init_simple_test("STT1162");
    static STRUCT_IF_C STT1162 lv;
    check2(sizeof(lv), 8, "sizeof(STT1162)");
    check2(__alignof__(lv), 4, "__alignof__(STT1162)");
    check_field_offset(lv, fa, 0, "STT1162.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1162");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1162");
    check_field_offset(lv, fb, 4, "STT1162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1162, STT1162)
//============================================================================


struct  STT1172  {
  short fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT1172) C1{ Fs Fi:3 Fi}



static void Test_STT1172()
{
  {
    init_simple_test("STT1172");
    static STRUCT_IF_C STT1172 lv;
    check2(sizeof(lv), 8, "sizeof(STT1172)");
    check2(__alignof__(lv), 4, "__alignof__(STT1172)");
    check_field_offset(lv, fa, 0, "STT1172.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1172");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1172");
    check_field_offset(lv, fb, 4, "STT1172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1172, STT1172)
//============================================================================


struct  STT1182  {
  short fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT1182) C1{ Fs FL:3 Fi}



static void Test_STT1182()
{
  {
    init_simple_test("STT1182");
    static STRUCT_IF_C STT1182 lv;
    check2(sizeof(lv), 8, "sizeof(STT1182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1182)");
    check_field_offset(lv, fa, 0, "STT1182.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1182");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1182");
    check_field_offset(lv, fb, 4, "STT1182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1182, STT1182)
//============================================================================


struct  STT1192  {
  short fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT1192) C1{ Fs Fs:8 Fi}



static void Test_STT1192()
{
  {
    init_simple_test("STT1192");
    static STRUCT_IF_C STT1192 lv;
    check2(sizeof(lv), 8, "sizeof(STT1192)");
    check2(__alignof__(lv), 4, "__alignof__(STT1192)");
    check_field_offset(lv, fa, 0, "STT1192.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1192");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1192");
    check_field_offset(lv, fb, 4, "STT1192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1192, STT1192)
//============================================================================


struct  STT1202  {
  short fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT1202) C1{ Fs Fi:8 Fi}



static void Test_STT1202()
{
  {
    init_simple_test("STT1202");
    static STRUCT_IF_C STT1202 lv;
    check2(sizeof(lv), 8, "sizeof(STT1202)");
    check2(__alignof__(lv), 4, "__alignof__(STT1202)");
    check_field_offset(lv, fa, 0, "STT1202.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1202");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1202");
    check_field_offset(lv, fb, 4, "STT1202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1202, STT1202)
//============================================================================


struct  STT1212  {
  short fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT1212) C1{ Fs FL:8 Fi}



static void Test_STT1212()
{
  {
    init_simple_test("STT1212");
    static STRUCT_IF_C STT1212 lv;
    check2(sizeof(lv), 8, "sizeof(STT1212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1212)");
    check_field_offset(lv, fa, 0, "STT1212.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1212");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1212");
    check_field_offset(lv, fb, 4, "STT1212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1212, STT1212)
//============================================================================


struct  STT1222  {
  short fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT1222) C1{ Fs Fi:18 Fi}



static void Test_STT1222()
{
  {
    init_simple_test("STT1222");
    static STRUCT_IF_C STT1222 lv;
    check2(sizeof(lv), 12, "sizeof(STT1222)");
    check2(__alignof__(lv), 4, "__alignof__(STT1222)");
    check_field_offset(lv, fa, 0, "STT1222.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1222");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1222");
    check_field_offset(lv, fb, 8, "STT1222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1222, STT1222)
//============================================================================


struct  STT1232  {
  short fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT1232) C1{ Fs FL:18 Fi}



static void Test_STT1232()
{
  {
    init_simple_test("STT1232");
    static STRUCT_IF_C STT1232 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1232)");
    check_field_offset(lv, fa, 0, "STT1232.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1232");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1232");
    check_field_offset(lv, fb, 8, "STT1232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1232, STT1232)
//============================================================================


struct  STT1242  {
  short fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT1242) C1{ Fs FL:48 Fi}



static void Test_STT1242()
{
  {
    init_simple_test("STT1242");
    static STRUCT_IF_C STT1242 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1242)");
    check_field_offset(lv, fa, 0, "STT1242.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1242");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1242");
    check_field_offset(lv, fb, 8, "STT1242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1242, STT1242)
//============================================================================


struct  STT113  {
  short fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT113) C1{ Fs Fc:0 Fl}



static void Test_STT113()
{
  {
    init_simple_test("STT113");
    static STRUCT_IF_C STT113 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT113)");
    check_field_offset(lv, fa, 0, "STT113.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT113, STT113)
//============================================================================


struct  STT123  {
  short fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT123) C1{ Fs Fs:0 Fl}



static void Test_STT123()
{
  {
    init_simple_test("STT123");
    static STRUCT_IF_C STT123 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT123)");
    check_field_offset(lv, fa, 0, "STT123.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT123, STT123)
//============================================================================


struct  STT133  {
  short fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT133) C1{ Fs Fi:0 Fl}



static void Test_STT133()
{
  {
    init_simple_test("STT133");
    static STRUCT_IF_C STT133 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT133)");
    check_field_offset(lv, fa, 0, "STT133.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT133, STT133)
//============================================================================


struct  STT143  {
  short fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT143) C1{ Fs FL:0 Fl}



static void Test_STT143()
{
  {
    init_simple_test("STT143");
    static STRUCT_IF_C STT143 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT143)");
    check_field_offset(lv, fa, 0, "STT143.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT143, STT143)
//============================================================================


struct  STT153  {
  short fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT153) C1{ Fs Fc:3 Fl}



static void Test_STT153()
{
  {
    init_simple_test("STT153");
    static STRUCT_IF_C STT153 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT153)");
    check_field_offset(lv, fa, 0, "STT153.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT153, STT153)
//============================================================================


struct  STT163  {
  short fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT163) C1{ Fs Fs:3 Fl}



static void Test_STT163()
{
  {
    init_simple_test("STT163");
    static STRUCT_IF_C STT163 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT163)");
    check_field_offset(lv, fa, 0, "STT163.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT163, STT163)
//============================================================================


struct  STT173  {
  short fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT173) C1{ Fs Fi:3 Fl}



static void Test_STT173()
{
  {
    init_simple_test("STT173");
    static STRUCT_IF_C STT173 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT173)");
    check_field_offset(lv, fa, 0, "STT173.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT173, STT173)
//============================================================================


struct  STT183  {
  short fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT183) C1{ Fs FL:3 Fl}



static void Test_STT183()
{
  {
    init_simple_test("STT183");
    static STRUCT_IF_C STT183 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT183)");
    check_field_offset(lv, fa, 0, "STT183.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT183, STT183)
//============================================================================


struct  STT193  {
  short fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT193) C1{ Fs Fs:8 Fl}



static void Test_STT193()
{
  {
    init_simple_test("STT193");
    static STRUCT_IF_C STT193 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT193)");
    check_field_offset(lv, fa, 0, "STT193.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT193, STT193)
//============================================================================


struct  STT1103  {
  short fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT1103) C1{ Fs Fi:8 Fl}



static void Test_STT1103()
{
  {
    init_simple_test("STT1103");
    static STRUCT_IF_C STT1103 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1103)");
    check_field_offset(lv, fa, 0, "STT1103.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1103, STT1103)
//============================================================================


struct  STT1113  {
  short fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT1113) C1{ Fs FL:8 Fl}



static void Test_STT1113()
{
  {
    init_simple_test("STT1113");
    static STRUCT_IF_C STT1113 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1113)");
    check_field_offset(lv, fa, 0, "STT1113.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1113, STT1113)
//============================================================================


struct  STT1123  {
  short fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT1123) C1{ Fs Fi:18 Fl}



static void Test_STT1123()
{
  {
    init_simple_test("STT1123");
    static STRUCT_IF_C STT1123 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1123)");
    check_field_offset(lv, fa, 0, "STT1123.fa");
    check_field_offset(lv, fb, 8, "STT1123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1123, STT1123)
//============================================================================


struct  STT1133  {
  short fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT1133) C1{ Fs FL:18 Fl}



static void Test_STT1133()
{
  {
    init_simple_test("STT1133");
    static STRUCT_IF_C STT1133 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1133)");
    check_field_offset(lv, fa, 0, "STT1133.fa");
    check_field_offset(lv, fb, 8, "STT1133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1133, STT1133)
//============================================================================


struct  STT1143  {
  short fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT1143) C1{ Fs FL:48 Fl}



static void Test_STT1143()
{
  {
    init_simple_test("STT1143");
    static STRUCT_IF_C STT1143 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1143)");
    check_field_offset(lv, fa, 0, "STT1143.fa");
    check_field_offset(lv, fb, 8, "STT1143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1143, STT1143)
//============================================================================


struct  STT1153  {
  short fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT1153) C1{ Fs Fc:3 Fl}



static void Test_STT1153()
{
  {
    init_simple_test("STT1153");
    static STRUCT_IF_C STT1153 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1153)");
    check_field_offset(lv, fa, 0, "STT1153.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1153");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1153");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1153, STT1153)
//============================================================================


struct  STT1163  {
  short fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT1163) C1{ Fs Fs:3 Fl}



static void Test_STT1163()
{
  {
    init_simple_test("STT1163");
    static STRUCT_IF_C STT1163 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1163)");
    check_field_offset(lv, fa, 0, "STT1163.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1163");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1163");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1163, STT1163)
//============================================================================


struct  STT1173  {
  short fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT1173) C1{ Fs Fi:3 Fl}



static void Test_STT1173()
{
  {
    init_simple_test("STT1173");
    static STRUCT_IF_C STT1173 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1173)");
    check_field_offset(lv, fa, 0, "STT1173.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1173");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1173");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1173, STT1173)
//============================================================================


struct  STT1183  {
  short fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT1183) C1{ Fs FL:3 Fl}



static void Test_STT1183()
{
  {
    init_simple_test("STT1183");
    static STRUCT_IF_C STT1183 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1183)");
    check_field_offset(lv, fa, 0, "STT1183.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1183");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1183");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1183, STT1183)
//============================================================================


struct  STT1193  {
  short fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT1193) C1{ Fs Fs:8 Fl}



static void Test_STT1193()
{
  {
    init_simple_test("STT1193");
    static STRUCT_IF_C STT1193 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1193)");
    check_field_offset(lv, fa, 0, "STT1193.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1193");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1193");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1193, STT1193)
//============================================================================


struct  STT1203  {
  short fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT1203) C1{ Fs Fi:8 Fl}



static void Test_STT1203()
{
  {
    init_simple_test("STT1203");
    static STRUCT_IF_C STT1203 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1203)");
    check_field_offset(lv, fa, 0, "STT1203.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1203");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1203");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1203, STT1203)
//============================================================================


struct  STT1213  {
  short fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT1213) C1{ Fs FL:8 Fl}



static void Test_STT1213()
{
  {
    init_simple_test("STT1213");
    static STRUCT_IF_C STT1213 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1213)");
    check_field_offset(lv, fa, 0, "STT1213.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1213");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1213");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1213, STT1213)
//============================================================================


struct  STT1223  {
  short fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT1223) C1{ Fs Fi:18 Fl}



static void Test_STT1223()
{
  {
    init_simple_test("STT1223");
    static STRUCT_IF_C STT1223 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1223)");
    check_field_offset(lv, fa, 0, "STT1223.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1223");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1223");
    check_field_offset(lv, fb, 8, "STT1223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1223, STT1223)
//============================================================================


struct  STT1233  {
  short fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT1233) C1{ Fs FL:18 Fl}



static void Test_STT1233()
{
  {
    init_simple_test("STT1233");
    static STRUCT_IF_C STT1233 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1233)");
    check_field_offset(lv, fa, 0, "STT1233.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1233");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1233");
    check_field_offset(lv, fb, 8, "STT1233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1233, STT1233)
//============================================================================


struct  STT1243  {
  short fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT1243) C1{ Fs FL:48 Fl}



static void Test_STT1243()
{
  {
    init_simple_test("STT1243");
    static STRUCT_IF_C STT1243 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1243)");
    check_field_offset(lv, fa, 0, "STT1243.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1243");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1243");
    check_field_offset(lv, fb, 8, "STT1243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1243, STT1243)
//============================================================================


struct  STT114  {
  short fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT114) C1{ Fs Fc:0 FL}



static void Test_STT114()
{
  {
    init_simple_test("STT114");
    static STRUCT_IF_C STT114 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT114)");
    check_field_offset(lv, fa, 0, "STT114.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT114, STT114)
//============================================================================


struct  STT124  {
  short fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT124) C1{ Fs Fs:0 FL}



static void Test_STT124()
{
  {
    init_simple_test("STT124");
    static STRUCT_IF_C STT124 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT124)");
    check_field_offset(lv, fa, 0, "STT124.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT124, STT124)
//============================================================================


struct  STT134  {
  short fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT134) C1{ Fs Fi:0 FL}



static void Test_STT134()
{
  {
    init_simple_test("STT134");
    static STRUCT_IF_C STT134 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT134)");
    check_field_offset(lv, fa, 0, "STT134.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT134, STT134)
//============================================================================


struct  STT144  {
  short fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT144) C1{ Fs FL:0 FL}



static void Test_STT144()
{
  {
    init_simple_test("STT144");
    static STRUCT_IF_C STT144 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT144)");
    check_field_offset(lv, fa, 0, "STT144.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT144, STT144)
//============================================================================


struct  STT154  {
  short fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT154) C1{ Fs Fc:3 FL}



static void Test_STT154()
{
  {
    init_simple_test("STT154");
    static STRUCT_IF_C STT154 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT154)");
    check_field_offset(lv, fa, 0, "STT154.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT154, STT154)
//============================================================================


struct  STT164  {
  short fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT164) C1{ Fs Fs:3 FL}



static void Test_STT164()
{
  {
    init_simple_test("STT164");
    static STRUCT_IF_C STT164 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT164)");
    check_field_offset(lv, fa, 0, "STT164.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT164, STT164)
//============================================================================


struct  STT174  {
  short fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT174) C1{ Fs Fi:3 FL}



static void Test_STT174()
{
  {
    init_simple_test("STT174");
    static STRUCT_IF_C STT174 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT174)");
    check_field_offset(lv, fa, 0, "STT174.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT174, STT174)
//============================================================================


struct  STT184  {
  short fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT184) C1{ Fs FL:3 FL}



static void Test_STT184()
{
  {
    init_simple_test("STT184");
    static STRUCT_IF_C STT184 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT184)");
    check_field_offset(lv, fa, 0, "STT184.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT184, STT184)
//============================================================================


struct  STT194  {
  short fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT194) C1{ Fs Fs:8 FL}



static void Test_STT194()
{
  {
    init_simple_test("STT194");
    static STRUCT_IF_C STT194 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT194)");
    check_field_offset(lv, fa, 0, "STT194.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT194, STT194)
//============================================================================


struct  STT1104  {
  short fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT1104) C1{ Fs Fi:8 FL}



static void Test_STT1104()
{
  {
    init_simple_test("STT1104");
    static STRUCT_IF_C STT1104 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1104)");
    check_field_offset(lv, fa, 0, "STT1104.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1104, STT1104)
//============================================================================


struct  STT1114  {
  short fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT1114) C1{ Fs FL:8 FL}



static void Test_STT1114()
{
  {
    init_simple_test("STT1114");
    static STRUCT_IF_C STT1114 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1114)");
    check_field_offset(lv, fa, 0, "STT1114.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1114, STT1114)
//============================================================================


struct  STT1124  {
  short fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT1124) C1{ Fs Fi:18 FL}



static void Test_STT1124()
{
  {
    init_simple_test("STT1124");
    static STRUCT_IF_C STT1124 lv;
    check2(sizeof(lv), 16, "sizeof(STT1124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1124)");
    check_field_offset(lv, fa, 0, "STT1124.fa");
    check_field_offset(lv, fb, 8, "STT1124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1124, STT1124)
//============================================================================


struct  STT1134  {
  short fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT1134) C1{ Fs FL:18 FL}



static void Test_STT1134()
{
  {
    init_simple_test("STT1134");
    static STRUCT_IF_C STT1134 lv;
    check2(sizeof(lv), 16, "sizeof(STT1134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1134)");
    check_field_offset(lv, fa, 0, "STT1134.fa");
    check_field_offset(lv, fb, 8, "STT1134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1134, STT1134)
//============================================================================


struct  STT1144  {
  short fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT1144) C1{ Fs FL:48 FL}



static void Test_STT1144()
{
  {
    init_simple_test("STT1144");
    static STRUCT_IF_C STT1144 lv;
    check2(sizeof(lv), 16, "sizeof(STT1144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1144)");
    check_field_offset(lv, fa, 0, "STT1144.fa");
    check_field_offset(lv, fb, 8, "STT1144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1144, STT1144)
//============================================================================


struct  STT1154  {
  short fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT1154) C1{ Fs Fc:3 FL}



static void Test_STT1154()
{
  {
    init_simple_test("STT1154");
    static STRUCT_IF_C STT1154 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1154)");
    check_field_offset(lv, fa, 0, "STT1154.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1154");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1154");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1154, STT1154)
//============================================================================


struct  STT1164  {
  short fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT1164) C1{ Fs Fs:3 FL}



static void Test_STT1164()
{
  {
    init_simple_test("STT1164");
    static STRUCT_IF_C STT1164 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1164)");
    check_field_offset(lv, fa, 0, "STT1164.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1164");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1164");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1164, STT1164)
//============================================================================


struct  STT1174  {
  short fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT1174) C1{ Fs Fi:3 FL}



static void Test_STT1174()
{
  {
    init_simple_test("STT1174");
    static STRUCT_IF_C STT1174 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1174)");
    check_field_offset(lv, fa, 0, "STT1174.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1174");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1174");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1174, STT1174)
//============================================================================


struct  STT1184  {
  short fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT1184) C1{ Fs FL:3 FL}



static void Test_STT1184()
{
  {
    init_simple_test("STT1184");
    static STRUCT_IF_C STT1184 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1184)");
    check_field_offset(lv, fa, 0, "STT1184.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1184");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1184");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1184, STT1184)
//============================================================================


struct  STT1194  {
  short fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT1194) C1{ Fs Fs:8 FL}



static void Test_STT1194()
{
  {
    init_simple_test("STT1194");
    static STRUCT_IF_C STT1194 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1194)");
    check_field_offset(lv, fa, 0, "STT1194.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1194");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1194");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1194, STT1194)
//============================================================================


struct  STT1204  {
  short fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT1204) C1{ Fs Fi:8 FL}



static void Test_STT1204()
{
  {
    init_simple_test("STT1204");
    static STRUCT_IF_C STT1204 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1204)");
    check_field_offset(lv, fa, 0, "STT1204.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1204");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1204");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1204, STT1204)
//============================================================================


struct  STT1214  {
  short fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT1214) C1{ Fs FL:8 FL}



static void Test_STT1214()
{
  {
    init_simple_test("STT1214");
    static STRUCT_IF_C STT1214 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1214)");
    check_field_offset(lv, fa, 0, "STT1214.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1214");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1214");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1214, STT1214)
//============================================================================


struct  STT1224  {
  short fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT1224) C1{ Fs Fi:18 FL}



static void Test_STT1224()
{
  {
    init_simple_test("STT1224");
    static STRUCT_IF_C STT1224 lv;
    check2(sizeof(lv), 16, "sizeof(STT1224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1224)");
    check_field_offset(lv, fa, 0, "STT1224.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1224");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1224");
    check_field_offset(lv, fb, 8, "STT1224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1224, STT1224)
//============================================================================


struct  STT1234  {
  short fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT1234) C1{ Fs FL:18 FL}



static void Test_STT1234()
{
  {
    init_simple_test("STT1234");
    static STRUCT_IF_C STT1234 lv;
    check2(sizeof(lv), 16, "sizeof(STT1234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1234)");
    check_field_offset(lv, fa, 0, "STT1234.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1234");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1234");
    check_field_offset(lv, fb, 8, "STT1234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1234, STT1234)
//============================================================================


struct  STT1244  {
  short fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT1244) C1{ Fs FL:48 FL}



static void Test_STT1244()
{
  {
    init_simple_test("STT1244");
    static STRUCT_IF_C STT1244 lv;
    check2(sizeof(lv), 16, "sizeof(STT1244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1244)");
    check_field_offset(lv, fa, 0, "STT1244.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1244");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1244");
    check_field_offset(lv, fb, 8, "STT1244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1244, STT1244)
//============================================================================


struct  STT115  {
  short fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT115) C1{ Fs Fc:0 Fp}



static void Test_STT115()
{
  {
    init_simple_test("STT115");
    static STRUCT_IF_C STT115 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT115)");
    check_field_offset(lv, fa, 0, "STT115.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT115, STT115)
//============================================================================


struct  STT125  {
  short fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT125) C1{ Fs Fs:0 Fp}



static void Test_STT125()
{
  {
    init_simple_test("STT125");
    static STRUCT_IF_C STT125 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT125)");
    check_field_offset(lv, fa, 0, "STT125.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT125, STT125)
//============================================================================


struct  STT135  {
  short fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT135) C1{ Fs Fi:0 Fp}



static void Test_STT135()
{
  {
    init_simple_test("STT135");
    static STRUCT_IF_C STT135 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT135)");
    check_field_offset(lv, fa, 0, "STT135.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT135, STT135)
//============================================================================


struct  STT145  {
  short fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT145) C1{ Fs FL:0 Fp}



static void Test_STT145()
{
  {
    init_simple_test("STT145");
    static STRUCT_IF_C STT145 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT145)");
    check_field_offset(lv, fa, 0, "STT145.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT145, STT145)
//============================================================================


struct  STT155  {
  short fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT155) C1{ Fs Fc:3 Fp}



static void Test_STT155()
{
  {
    init_simple_test("STT155");
    static STRUCT_IF_C STT155 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT155)");
    check_field_offset(lv, fa, 0, "STT155.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT155, STT155)
//============================================================================


struct  STT165  {
  short fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT165) C1{ Fs Fs:3 Fp}



static void Test_STT165()
{
  {
    init_simple_test("STT165");
    static STRUCT_IF_C STT165 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT165)");
    check_field_offset(lv, fa, 0, "STT165.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT165, STT165)
//============================================================================


struct  STT175  {
  short fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT175) C1{ Fs Fi:3 Fp}



static void Test_STT175()
{
  {
    init_simple_test("STT175");
    static STRUCT_IF_C STT175 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT175)");
    check_field_offset(lv, fa, 0, "STT175.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT175, STT175)
//============================================================================


struct  STT185  {
  short fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT185) C1{ Fs FL:3 Fp}



static void Test_STT185()
{
  {
    init_simple_test("STT185");
    static STRUCT_IF_C STT185 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT185)");
    check_field_offset(lv, fa, 0, "STT185.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT185, STT185)
//============================================================================


struct  STT195  {
  short fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT195) C1{ Fs Fs:8 Fp}



static void Test_STT195()
{
  {
    init_simple_test("STT195");
    static STRUCT_IF_C STT195 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT195)");
    check_field_offset(lv, fa, 0, "STT195.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT195, STT195)
//============================================================================


struct  STT1105  {
  short fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT1105) C1{ Fs Fi:8 Fp}



static void Test_STT1105()
{
  {
    init_simple_test("STT1105");
    static STRUCT_IF_C STT1105 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1105)");
    check_field_offset(lv, fa, 0, "STT1105.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1105, STT1105)
//============================================================================


struct  STT1115  {
  short fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT1115) C1{ Fs FL:8 Fp}



static void Test_STT1115()
{
  {
    init_simple_test("STT1115");
    static STRUCT_IF_C STT1115 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1115)");
    check_field_offset(lv, fa, 0, "STT1115.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1115, STT1115)
//============================================================================


struct  STT1125  {
  short fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT1125) C1{ Fs Fi:18 Fp}



static void Test_STT1125()
{
  {
    init_simple_test("STT1125");
    static STRUCT_IF_C STT1125 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1125)");
    check_field_offset(lv, fa, 0, "STT1125.fa");
    check_field_offset(lv, fb, 8, "STT1125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1125, STT1125)
//============================================================================


struct  STT1135  {
  short fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT1135) C1{ Fs FL:18 Fp}



static void Test_STT1135()
{
  {
    init_simple_test("STT1135");
    static STRUCT_IF_C STT1135 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1135)");
    check_field_offset(lv, fa, 0, "STT1135.fa");
    check_field_offset(lv, fb, 8, "STT1135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1135, STT1135)
//============================================================================


struct  STT1145  {
  short fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT1145) C1{ Fs FL:48 Fp}



static void Test_STT1145()
{
  {
    init_simple_test("STT1145");
    static STRUCT_IF_C STT1145 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1145)");
    check_field_offset(lv, fa, 0, "STT1145.fa");
    check_field_offset(lv, fb, 8, "STT1145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1145, STT1145)
//============================================================================


struct  STT1155  {
  short fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT1155) C1{ Fs Fc:3 Fp}



static void Test_STT1155()
{
  {
    init_simple_test("STT1155");
    static STRUCT_IF_C STT1155 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1155)");
    check_field_offset(lv, fa, 0, "STT1155.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1155");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1155");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1155, STT1155)
//============================================================================


struct  STT1165  {
  short fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT1165) C1{ Fs Fs:3 Fp}



static void Test_STT1165()
{
  {
    init_simple_test("STT1165");
    static STRUCT_IF_C STT1165 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1165)");
    check_field_offset(lv, fa, 0, "STT1165.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1165");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1165");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1165, STT1165)
//============================================================================


struct  STT1175  {
  short fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT1175) C1{ Fs Fi:3 Fp}



static void Test_STT1175()
{
  {
    init_simple_test("STT1175");
    static STRUCT_IF_C STT1175 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1175)");
    check_field_offset(lv, fa, 0, "STT1175.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1175");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1175");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1175, STT1175)
//============================================================================


struct  STT1185  {
  short fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT1185) C1{ Fs FL:3 Fp}



static void Test_STT1185()
{
  {
    init_simple_test("STT1185");
    static STRUCT_IF_C STT1185 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1185)");
    check_field_offset(lv, fa, 0, "STT1185.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1185");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1185");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1185, STT1185)
//============================================================================


struct  STT1195  {
  short fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT1195) C1{ Fs Fs:8 Fp}



static void Test_STT1195()
{
  {
    init_simple_test("STT1195");
    static STRUCT_IF_C STT1195 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1195)");
    check_field_offset(lv, fa, 0, "STT1195.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1195");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1195");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1195, STT1195)
//============================================================================


struct  STT1205  {
  short fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT1205) C1{ Fs Fi:8 Fp}



static void Test_STT1205()
{
  {
    init_simple_test("STT1205");
    static STRUCT_IF_C STT1205 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1205)");
    check_field_offset(lv, fa, 0, "STT1205.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1205");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1205");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1205, STT1205)
//============================================================================


struct  STT1215  {
  short fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT1215) C1{ Fs FL:8 Fp}



static void Test_STT1215()
{
  {
    init_simple_test("STT1215");
    static STRUCT_IF_C STT1215 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT1215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1215)");
    check_field_offset(lv, fa, 0, "STT1215.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1215");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1215");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1215, STT1215)
//============================================================================


struct  STT1225  {
  short fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT1225) C1{ Fs Fi:18 Fp}



static void Test_STT1225()
{
  {
    init_simple_test("STT1225");
    static STRUCT_IF_C STT1225 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1225)");
    check_field_offset(lv, fa, 0, "STT1225.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1225");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1225");
    check_field_offset(lv, fb, 8, "STT1225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1225, STT1225)
//============================================================================


struct  STT1235  {
  short fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT1235) C1{ Fs FL:18 Fp}



static void Test_STT1235()
{
  {
    init_simple_test("STT1235");
    static STRUCT_IF_C STT1235 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1235)");
    check_field_offset(lv, fa, 0, "STT1235.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1235");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1235");
    check_field_offset(lv, fb, 8, "STT1235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1235, STT1235)
//============================================================================


struct  STT1245  {
  short fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT1245) C1{ Fs FL:48 Fp}



static void Test_STT1245()
{
  {
    init_simple_test("STT1245");
    static STRUCT_IF_C STT1245 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1245)");
    check_field_offset(lv, fa, 0, "STT1245.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1245");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1245");
    check_field_offset(lv, fb, 8, "STT1245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1245, STT1245)
//============================================================================


struct  STT116  {
  short fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT116) C1{ Fs Fc:0 Fi}



static void Test_STT116()
{
  {
    init_simple_test("STT116");
    static STRUCT_IF_C STT116 lv;
    check2(sizeof(lv), 8, "sizeof(STT116)");
    check2(__alignof__(lv), 4, "__alignof__(STT116)");
    check_field_offset(lv, fa, 0, "STT116.fa");
    check_field_offset(lv, fb, 4, "STT116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT116, STT116)
//============================================================================


struct  STT126  {
  short fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT126) C1{ Fs Fs:0 Fi}



static void Test_STT126()
{
  {
    init_simple_test("STT126");
    static STRUCT_IF_C STT126 lv;
    check2(sizeof(lv), 8, "sizeof(STT126)");
    check2(__alignof__(lv), 4, "__alignof__(STT126)");
    check_field_offset(lv, fa, 0, "STT126.fa");
    check_field_offset(lv, fb, 4, "STT126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT126, STT126)
//============================================================================


struct  STT136  {
  short fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT136) C1{ Fs Fi:0 Fi}



static void Test_STT136()
{
  {
    init_simple_test("STT136");
    static STRUCT_IF_C STT136 lv;
    check2(sizeof(lv), 8, "sizeof(STT136)");
    check2(__alignof__(lv), 4, "__alignof__(STT136)");
    check_field_offset(lv, fa, 0, "STT136.fa");
    check_field_offset(lv, fb, 4, "STT136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT136, STT136)
//============================================================================


struct  STT146  {
  short fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT146) C1{ Fs FL:0 Fi}



static void Test_STT146()
{
  {
    init_simple_test("STT146");
    static STRUCT_IF_C STT146 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT146)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT146)");
    check_field_offset(lv, fa, 0, "STT146.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT146, STT146)
//============================================================================


struct  STT156  {
  short fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT156) C1{ Fs Fc:3 Fi}



static void Test_STT156()
{
  {
    init_simple_test("STT156");
    static STRUCT_IF_C STT156 lv;
    check2(sizeof(lv), 8, "sizeof(STT156)");
    check2(__alignof__(lv), 4, "__alignof__(STT156)");
    check_field_offset(lv, fa, 0, "STT156.fa");
    check_field_offset(lv, fb, 4, "STT156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT156, STT156)
//============================================================================


struct  STT166  {
  short fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT166) C1{ Fs Fs:3 Fi}



static void Test_STT166()
{
  {
    init_simple_test("STT166");
    static STRUCT_IF_C STT166 lv;
    check2(sizeof(lv), 8, "sizeof(STT166)");
    check2(__alignof__(lv), 4, "__alignof__(STT166)");
    check_field_offset(lv, fa, 0, "STT166.fa");
    check_field_offset(lv, fb, 4, "STT166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT166, STT166)
//============================================================================


struct  STT176  {
  short fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT176) C1{ Fs Fi:3 Fi}



static void Test_STT176()
{
  {
    init_simple_test("STT176");
    static STRUCT_IF_C STT176 lv;
    check2(sizeof(lv), 8, "sizeof(STT176)");
    check2(__alignof__(lv), 4, "__alignof__(STT176)");
    check_field_offset(lv, fa, 0, "STT176.fa");
    check_field_offset(lv, fb, 4, "STT176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT176, STT176)
//============================================================================


struct  STT186  {
  short fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT186) C1{ Fs FL:3 Fi}



static void Test_STT186()
{
  {
    init_simple_test("STT186");
    static STRUCT_IF_C STT186 lv;
    check2(sizeof(lv), 8, "sizeof(STT186)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT186)");
    check_field_offset(lv, fa, 0, "STT186.fa");
    check_field_offset(lv, fb, 4, "STT186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT186, STT186)
//============================================================================


struct  STT196  {
  short fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT196) C1{ Fs Fs:8 Fi}



static void Test_STT196()
{
  {
    init_simple_test("STT196");
    static STRUCT_IF_C STT196 lv;
    check2(sizeof(lv), 8, "sizeof(STT196)");
    check2(__alignof__(lv), 4, "__alignof__(STT196)");
    check_field_offset(lv, fa, 0, "STT196.fa");
    check_field_offset(lv, fb, 4, "STT196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT196, STT196)
//============================================================================


struct  STT1106  {
  short fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT1106) C1{ Fs Fi:8 Fi}



static void Test_STT1106()
{
  {
    init_simple_test("STT1106");
    static STRUCT_IF_C STT1106 lv;
    check2(sizeof(lv), 8, "sizeof(STT1106)");
    check2(__alignof__(lv), 4, "__alignof__(STT1106)");
    check_field_offset(lv, fa, 0, "STT1106.fa");
    check_field_offset(lv, fb, 4, "STT1106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1106, STT1106)
//============================================================================


struct  STT1116  {
  short fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT1116) C1{ Fs FL:8 Fi}



static void Test_STT1116()
{
  {
    init_simple_test("STT1116");
    static STRUCT_IF_C STT1116 lv;
    check2(sizeof(lv), 8, "sizeof(STT1116)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT1116)");
    check_field_offset(lv, fa, 0, "STT1116.fa");
    check_field_offset(lv, fb, 4, "STT1116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1116, STT1116)
//============================================================================


struct  STT1126  {
  short fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT1126) C1{ Fs Fi:18 Fi}



static void Test_STT1126()
{
  {
    init_simple_test("STT1126");
    static STRUCT_IF_C STT1126 lv;
    check2(sizeof(lv), 12, "sizeof(STT1126)");
    check2(__alignof__(lv), 4, "__alignof__(STT1126)");
    check_field_offset(lv, fa, 0, "STT1126.fa");
    check_field_offset(lv, fb, 8, "STT1126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1126, STT1126)
//============================================================================


struct  STT1136  {
  short fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT1136) C1{ Fs FL:18 Fi}



static void Test_STT1136()
{
  {
    init_simple_test("STT1136");
    static STRUCT_IF_C STT1136 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT1136)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT1136)");
    check_field_offset(lv, fa, 0, "STT1136.fa");
    check_field_offset(lv, fb, 8, "STT1136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1136, STT1136)
//============================================================================


struct  STT1146  {
  short fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT1146) C1{ Fs FL:48 Fi}



static void Test_STT1146()
{
  {
    init_simple_test("STT1146");
    static STRUCT_IF_C STT1146 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT1146)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT1146)");
    check_field_offset(lv, fa, 0, "STT1146.fa");
    check_field_offset(lv, fb, 8, "STT1146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1146, STT1146)
//============================================================================


struct  STT1156  {
  short fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT1156) C1{ Fs Fc:3 Fi}



static void Test_STT1156()
{
  {
    init_simple_test("STT1156");
    static STRUCT_IF_C STT1156 lv;
    check2(sizeof(lv), 8, "sizeof(STT1156)");
    check2(__alignof__(lv), 4, "__alignof__(STT1156)");
    check_field_offset(lv, fa, 0, "STT1156.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1156");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1156");
    check_field_offset(lv, fb, 4, "STT1156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1156, STT1156)
//============================================================================


struct  STT1166  {
  short fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT1166) C1{ Fs Fs:3 Fi}



static void Test_STT1166()
{
  {
    init_simple_test("STT1166");
    static STRUCT_IF_C STT1166 lv;
    check2(sizeof(lv), 8, "sizeof(STT1166)");
    check2(__alignof__(lv), 4, "__alignof__(STT1166)");
    check_field_offset(lv, fa, 0, "STT1166.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1166");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1166");
    check_field_offset(lv, fb, 4, "STT1166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1166, STT1166)
//============================================================================


struct  STT1176  {
  short fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT1176) C1{ Fs Fi:3 Fi}



static void Test_STT1176()
{
  {
    init_simple_test("STT1176");
    static STRUCT_IF_C STT1176 lv;
    check2(sizeof(lv), 8, "sizeof(STT1176)");
    check2(__alignof__(lv), 4, "__alignof__(STT1176)");
    check_field_offset(lv, fa, 0, "STT1176.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1176");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1176");
    check_field_offset(lv, fb, 4, "STT1176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1176, STT1176)
//============================================================================


struct  STT1186  {
  short fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT1186) C1{ Fs FL:3 Fi}



static void Test_STT1186()
{
  {
    init_simple_test("STT1186");
    static STRUCT_IF_C STT1186 lv;
    check2(sizeof(lv), 8, "sizeof(STT1186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1186)");
    check_field_offset(lv, fa, 0, "STT1186.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1186");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1186");
    check_field_offset(lv, fb, 4, "STT1186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1186, STT1186)
//============================================================================


struct  STT1196  {
  short fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT1196) C1{ Fs Fs:8 Fi}



static void Test_STT1196()
{
  {
    init_simple_test("STT1196");
    static STRUCT_IF_C STT1196 lv;
    check2(sizeof(lv), 8, "sizeof(STT1196)");
    check2(__alignof__(lv), 4, "__alignof__(STT1196)");
    check_field_offset(lv, fa, 0, "STT1196.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1196");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1196");
    check_field_offset(lv, fb, 4, "STT1196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1196, STT1196)
//============================================================================


struct  STT1206  {
  short fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT1206) C1{ Fs Fi:8 Fi}



static void Test_STT1206()
{
  {
    init_simple_test("STT1206");
    static STRUCT_IF_C STT1206 lv;
    check2(sizeof(lv), 8, "sizeof(STT1206)");
    check2(__alignof__(lv), 4, "__alignof__(STT1206)");
    check_field_offset(lv, fa, 0, "STT1206.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1206");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1206");
    check_field_offset(lv, fb, 4, "STT1206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1206, STT1206)
//============================================================================


struct  STT1216  {
  short fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT1216) C1{ Fs FL:8 Fi}



static void Test_STT1216()
{
  {
    init_simple_test("STT1216");
    static STRUCT_IF_C STT1216 lv;
    check2(sizeof(lv), 8, "sizeof(STT1216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1216)");
    check_field_offset(lv, fa, 0, "STT1216.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1216");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1216");
    check_field_offset(lv, fb, 4, "STT1216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1216, STT1216)
//============================================================================


struct  STT1226  {
  short fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT1226) C1{ Fs Fi:18 Fi}



static void Test_STT1226()
{
  {
    init_simple_test("STT1226");
    static STRUCT_IF_C STT1226 lv;
    check2(sizeof(lv), 12, "sizeof(STT1226)");
    check2(__alignof__(lv), 4, "__alignof__(STT1226)");
    check_field_offset(lv, fa, 0, "STT1226.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1226");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1226");
    check_field_offset(lv, fb, 8, "STT1226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1226, STT1226)
//============================================================================


struct  STT1236  {
  short fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT1236) C1{ Fs FL:18 Fi}



static void Test_STT1236()
{
  {
    init_simple_test("STT1236");
    static STRUCT_IF_C STT1236 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1236)");
    check_field_offset(lv, fa, 0, "STT1236.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1236");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1236");
    check_field_offset(lv, fb, 8, "STT1236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1236, STT1236)
//============================================================================


struct  STT1246  {
  short fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT1246) C1{ Fs FL:48 Fi}



static void Test_STT1246()
{
  {
    init_simple_test("STT1246");
    static STRUCT_IF_C STT1246 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1246)");
    check_field_offset(lv, fa, 0, "STT1246.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1246");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1246");
    check_field_offset(lv, fb, 8, "STT1246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1246, STT1246)
//============================================================================


struct  STT117  {
  short fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT117) C1{ Fs Fc:0 FL}



static void Test_STT117()
{
  {
    init_simple_test("STT117");
    static STRUCT_IF_C STT117 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT117)");
    check_field_offset(lv, fa, 0, "STT117.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT117, STT117)
//============================================================================


struct  STT127  {
  short fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT127) C1{ Fs Fs:0 FL}



static void Test_STT127()
{
  {
    init_simple_test("STT127");
    static STRUCT_IF_C STT127 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT127)");
    check_field_offset(lv, fa, 0, "STT127.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT127, STT127)
//============================================================================


struct  STT137  {
  short fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT137) C1{ Fs Fi:0 FL}



static void Test_STT137()
{
  {
    init_simple_test("STT137");
    static STRUCT_IF_C STT137 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT137)");
    check_field_offset(lv, fa, 0, "STT137.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT137, STT137)
//============================================================================


struct  STT147  {
  short fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT147) C1{ Fs FL:0 FL}



static void Test_STT147()
{
  {
    init_simple_test("STT147");
    static STRUCT_IF_C STT147 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT147)");
    check_field_offset(lv, fa, 0, "STT147.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT147, STT147)
//============================================================================


struct  STT157  {
  short fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT157) C1{ Fs Fc:3 FL}



static void Test_STT157()
{
  {
    init_simple_test("STT157");
    static STRUCT_IF_C STT157 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT157)");
    check_field_offset(lv, fa, 0, "STT157.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT157, STT157)
//============================================================================


struct  STT167  {
  short fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT167) C1{ Fs Fs:3 FL}



static void Test_STT167()
{
  {
    init_simple_test("STT167");
    static STRUCT_IF_C STT167 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT167)");
    check_field_offset(lv, fa, 0, "STT167.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT167, STT167)
//============================================================================


struct  STT177  {
  short fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT177) C1{ Fs Fi:3 FL}



static void Test_STT177()
{
  {
    init_simple_test("STT177");
    static STRUCT_IF_C STT177 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT177)");
    check_field_offset(lv, fa, 0, "STT177.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT177, STT177)
//============================================================================


struct  STT187  {
  short fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT187) C1{ Fs FL:3 FL}



static void Test_STT187()
{
  {
    init_simple_test("STT187");
    static STRUCT_IF_C STT187 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT187)");
    check_field_offset(lv, fa, 0, "STT187.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT187, STT187)
//============================================================================


struct  STT197  {
  short fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT197) C1{ Fs Fs:8 FL}



static void Test_STT197()
{
  {
    init_simple_test("STT197");
    static STRUCT_IF_C STT197 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT197)");
    check_field_offset(lv, fa, 0, "STT197.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT197, STT197)
//============================================================================


struct  STT1107  {
  short fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT1107) C1{ Fs Fi:8 FL}



static void Test_STT1107()
{
  {
    init_simple_test("STT1107");
    static STRUCT_IF_C STT1107 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1107)");
    check_field_offset(lv, fa, 0, "STT1107.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1107, STT1107)
//============================================================================


struct  STT1117  {
  short fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT1117) C1{ Fs FL:8 FL}



static void Test_STT1117()
{
  {
    init_simple_test("STT1117");
    static STRUCT_IF_C STT1117 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1117)");
    check_field_offset(lv, fa, 0, "STT1117.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1117, STT1117)
//============================================================================


struct  STT1127  {
  short fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT1127) C1{ Fs Fi:18 FL}



static void Test_STT1127()
{
  {
    init_simple_test("STT1127");
    static STRUCT_IF_C STT1127 lv;
    check2(sizeof(lv), 16, "sizeof(STT1127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1127)");
    check_field_offset(lv, fa, 0, "STT1127.fa");
    check_field_offset(lv, fb, 8, "STT1127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1127, STT1127)
//============================================================================


struct  STT1137  {
  short fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT1137) C1{ Fs FL:18 FL}



static void Test_STT1137()
{
  {
    init_simple_test("STT1137");
    static STRUCT_IF_C STT1137 lv;
    check2(sizeof(lv), 16, "sizeof(STT1137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1137)");
    check_field_offset(lv, fa, 0, "STT1137.fa");
    check_field_offset(lv, fb, 8, "STT1137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1137, STT1137)
//============================================================================


struct  STT1147  {
  short fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT1147) C1{ Fs FL:48 FL}



static void Test_STT1147()
{
  {
    init_simple_test("STT1147");
    static STRUCT_IF_C STT1147 lv;
    check2(sizeof(lv), 16, "sizeof(STT1147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1147)");
    check_field_offset(lv, fa, 0, "STT1147.fa");
    check_field_offset(lv, fb, 8, "STT1147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1147, STT1147)
//============================================================================


struct  STT1157  {
  short fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT1157) C1{ Fs Fc:3 FL}



static void Test_STT1157()
{
  {
    init_simple_test("STT1157");
    static STRUCT_IF_C STT1157 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1157)");
    check_field_offset(lv, fa, 0, "STT1157.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1157");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1157");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1157, STT1157)
//============================================================================


struct  STT1167  {
  short fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT1167) C1{ Fs Fs:3 FL}



static void Test_STT1167()
{
  {
    init_simple_test("STT1167");
    static STRUCT_IF_C STT1167 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1167)");
    check_field_offset(lv, fa, 0, "STT1167.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1167");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1167");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1167, STT1167)
//============================================================================


struct  STT1177  {
  short fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT1177) C1{ Fs Fi:3 FL}



static void Test_STT1177()
{
  {
    init_simple_test("STT1177");
    static STRUCT_IF_C STT1177 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1177)");
    check_field_offset(lv, fa, 0, "STT1177.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1177");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1177");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1177, STT1177)
//============================================================================


struct  STT1187  {
  short fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT1187) C1{ Fs FL:3 FL}



static void Test_STT1187()
{
  {
    init_simple_test("STT1187");
    static STRUCT_IF_C STT1187 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1187)");
    check_field_offset(lv, fa, 0, "STT1187.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1187");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1187");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1187, STT1187)
//============================================================================


struct  STT1197  {
  short fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT1197) C1{ Fs Fs:8 FL}



static void Test_STT1197()
{
  {
    init_simple_test("STT1197");
    static STRUCT_IF_C STT1197 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1197)");
    check_field_offset(lv, fa, 0, "STT1197.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1197");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1197");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1197, STT1197)
//============================================================================


struct  STT1207  {
  short fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT1207) C1{ Fs Fi:8 FL}



static void Test_STT1207()
{
  {
    init_simple_test("STT1207");
    static STRUCT_IF_C STT1207 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1207)");
    check_field_offset(lv, fa, 0, "STT1207.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1207");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1207");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1207, STT1207)
//============================================================================


struct  STT1217  {
  short fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT1217) C1{ Fs FL:8 FL}



static void Test_STT1217()
{
  {
    init_simple_test("STT1217");
    static STRUCT_IF_C STT1217 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT1217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1217)");
    check_field_offset(lv, fa, 0, "STT1217.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1217");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1217");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT1217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1217, STT1217)
//============================================================================


struct  STT1227  {
  short fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT1227) C1{ Fs Fi:18 FL}



static void Test_STT1227()
{
  {
    init_simple_test("STT1227");
    static STRUCT_IF_C STT1227 lv;
    check2(sizeof(lv), 16, "sizeof(STT1227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1227)");
    check_field_offset(lv, fa, 0, "STT1227.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1227");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1227");
    check_field_offset(lv, fb, 8, "STT1227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1227, STT1227)
//============================================================================


struct  STT1237  {
  short fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT1237) C1{ Fs FL:18 FL}



static void Test_STT1237()
{
  {
    init_simple_test("STT1237");
    static STRUCT_IF_C STT1237 lv;
    check2(sizeof(lv), 16, "sizeof(STT1237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1237)");
    check_field_offset(lv, fa, 0, "STT1237.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1237");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1237");
    check_field_offset(lv, fb, 8, "STT1237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1237, STT1237)
//============================================================================


struct  STT1247  {
  short fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT1247) C1{ Fs FL:48 FL}



static void Test_STT1247()
{
  {
    init_simple_test("STT1247");
    static STRUCT_IF_C STT1247 lv;
    check2(sizeof(lv), 16, "sizeof(STT1247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1247)");
    check_field_offset(lv, fa, 0, "STT1247.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1247");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1247");
    check_field_offset(lv, fb, 8, "STT1247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1247, STT1247)
//============================================================================


struct  STT118  {
  short fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT118) C1{ Fs Fc:0 FD}



static void Test_STT118()
{
  {
    init_simple_test("STT118");
    static STRUCT_IF_C STT118 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT118)");
    check_field_offset(lv, fa, 0, "STT118.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT118, STT118)
//============================================================================


struct  STT128  {
  short fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT128) C1{ Fs Fs:0 FD}



static void Test_STT128()
{
  {
    init_simple_test("STT128");
    static STRUCT_IF_C STT128 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT128)");
    check_field_offset(lv, fa, 0, "STT128.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT128, STT128)
//============================================================================


struct  STT138  {
  short fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT138) C1{ Fs Fi:0 FD}



static void Test_STT138()
{
  {
    init_simple_test("STT138");
    static STRUCT_IF_C STT138 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT138)");
    check_field_offset(lv, fa, 0, "STT138.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT138, STT138)
//============================================================================


struct  STT148  {
  short fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT148) C1{ Fs FL:0 FD}



static void Test_STT148()
{
  {
    init_simple_test("STT148");
    static STRUCT_IF_C STT148 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT148)");
    check_field_offset(lv, fa, 0, "STT148.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT148, STT148)
//============================================================================


struct  STT158  {
  short fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT158) C1{ Fs Fc:3 FD}



static void Test_STT158()
{
  {
    init_simple_test("STT158");
    static STRUCT_IF_C STT158 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT158)");
    check_field_offset(lv, fa, 0, "STT158.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT158, STT158)
//============================================================================


struct  STT168  {
  short fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT168) C1{ Fs Fs:3 FD}



static void Test_STT168()
{
  {
    init_simple_test("STT168");
    static STRUCT_IF_C STT168 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT168)");
    check_field_offset(lv, fa, 0, "STT168.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT168, STT168)
//============================================================================


struct  STT178  {
  short fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT178) C1{ Fs Fi:3 FD}



static void Test_STT178()
{
  {
    init_simple_test("STT178");
    static STRUCT_IF_C STT178 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT178)");
    check_field_offset(lv, fa, 0, "STT178.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT178, STT178)
//============================================================================


struct  STT188  {
  short fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT188) C1{ Fs FL:3 FD}



static void Test_STT188()
{
  {
    init_simple_test("STT188");
    static STRUCT_IF_C STT188 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT188)");
    check_field_offset(lv, fa, 0, "STT188.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT188, STT188)
//============================================================================


struct  STT198  {
  short fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT198) C1{ Fs Fs:8 FD}



static void Test_STT198()
{
  {
    init_simple_test("STT198");
    static STRUCT_IF_C STT198 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT198)");
    check_field_offset(lv, fa, 0, "STT198.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT198, STT198)
//============================================================================


struct  STT1108  {
  short fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT1108) C1{ Fs Fi:8 FD}



static void Test_STT1108()
{
  {
    init_simple_test("STT1108");
    static STRUCT_IF_C STT1108 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1108)");
    check_field_offset(lv, fa, 0, "STT1108.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1108, STT1108)
//============================================================================


struct  STT1118  {
  short fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT1118) C1{ Fs FL:8 FD}



static void Test_STT1118()
{
  {
    init_simple_test("STT1118");
    static STRUCT_IF_C STT1118 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1118)");
    check_field_offset(lv, fa, 0, "STT1118.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1118, STT1118)
//============================================================================


struct  STT1128  {
  short fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT1128) C1{ Fs Fi:18 FD}



static void Test_STT1128()
{
  {
    init_simple_test("STT1128");
    static STRUCT_IF_C STT1128 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT1128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1128)");
    check_field_offset(lv, fa, 0, "STT1128.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT1128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1128, STT1128)
//============================================================================


struct  STT1138  {
  short fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT1138) C1{ Fs FL:18 FD}



static void Test_STT1138()
{
  {
    init_simple_test("STT1138");
    static STRUCT_IF_C STT1138 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT1138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1138)");
    check_field_offset(lv, fa, 0, "STT1138.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT1138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1138, STT1138)
//============================================================================


struct  STT1148  {
  short fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT1148) C1{ Fs FL:48 FD}



static void Test_STT1148()
{
  {
    init_simple_test("STT1148");
    static STRUCT_IF_C STT1148 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT1148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1148)");
    check_field_offset(lv, fa, 0, "STT1148.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT1148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1148, STT1148)
//============================================================================


struct  STT1158  {
  short fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT1158) C1{ Fs Fc:3 FD}



static void Test_STT1158()
{
  {
    init_simple_test("STT1158");
    static STRUCT_IF_C STT1158 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1158)");
    check_field_offset(lv, fa, 0, "STT1158.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1158");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1158");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1158, STT1158)
//============================================================================


struct  STT1168  {
  short fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT1168) C1{ Fs Fs:3 FD}



static void Test_STT1168()
{
  {
    init_simple_test("STT1168");
    static STRUCT_IF_C STT1168 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1168)");
    check_field_offset(lv, fa, 0, "STT1168.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1168");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1168");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1168, STT1168)
//============================================================================


struct  STT1178  {
  short fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT1178) C1{ Fs Fi:3 FD}



static void Test_STT1178()
{
  {
    init_simple_test("STT1178");
    static STRUCT_IF_C STT1178 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1178)");
    check_field_offset(lv, fa, 0, "STT1178.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1178");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1178");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1178, STT1178)
//============================================================================


struct  STT1188  {
  short fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT1188) C1{ Fs FL:3 FD}



static void Test_STT1188()
{
  {
    init_simple_test("STT1188");
    static STRUCT_IF_C STT1188 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1188)");
    check_field_offset(lv, fa, 0, "STT1188.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1188");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1188");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1188, STT1188)
//============================================================================


struct  STT1198  {
  short fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT1198) C1{ Fs Fs:8 FD}



static void Test_STT1198()
{
  {
    init_simple_test("STT1198");
    static STRUCT_IF_C STT1198 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1198)");
    check_field_offset(lv, fa, 0, "STT1198.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1198");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1198");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1198, STT1198)
//============================================================================


struct  STT1208  {
  short fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT1208) C1{ Fs Fi:8 FD}



static void Test_STT1208()
{
  {
    init_simple_test("STT1208");
    static STRUCT_IF_C STT1208 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1208)");
    check_field_offset(lv, fa, 0, "STT1208.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1208");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1208");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1208, STT1208)
//============================================================================


struct  STT1218  {
  short fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT1218) C1{ Fs FL:8 FD}



static void Test_STT1218()
{
  {
    init_simple_test("STT1218");
    static STRUCT_IF_C STT1218 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT1218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1218)");
    check_field_offset(lv, fa, 0, "STT1218.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1218");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1218");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT1218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1218, STT1218)
//============================================================================


struct  STT1228  {
  short fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT1228) C1{ Fs Fi:18 FD}



static void Test_STT1228()
{
  {
    init_simple_test("STT1228");
    static STRUCT_IF_C STT1228 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT1228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1228)");
    check_field_offset(lv, fa, 0, "STT1228.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1228");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1228");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT1228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1228, STT1228)
//============================================================================


struct  STT1238  {
  short fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT1238) C1{ Fs FL:18 FD}



static void Test_STT1238()
{
  {
    init_simple_test("STT1238");
    static STRUCT_IF_C STT1238 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT1238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1238)");
    check_field_offset(lv, fa, 0, "STT1238.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1238");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1238");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT1238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1238, STT1238)
//============================================================================


struct  STT1248  {
  short fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT1248) C1{ Fs FL:48 FD}



static void Test_STT1248()
{
  {
    init_simple_test("STT1248");
    static STRUCT_IF_C STT1248 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT1248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT1248)");
    check_field_offset(lv, fa, 0, "STT1248.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1248");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1248");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT1248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1248, STT1248)
//============================================================================


struct  STT119  {
  short fa;
  unsigned char  :0;
};
//SIG(1 STT119) C1{ Fs Fc:0}



static void Test_STT119()
{
  {
    init_simple_test("STT119");
    static STRUCT_IF_C STT119 lv;
    check2(sizeof(lv), 2, "sizeof(STT119)");
    check2(__alignof__(lv), 2, "__alignof__(STT119)");
    check_field_offset(lv, fa, 0, "STT119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT119, STT119)
//============================================================================


struct  STT129  {
  short fa;
  unsigned short  :0;
};
//SIG(1 STT129) C1{ Fs Fs:0}



static void Test_STT129()
{
  {
    init_simple_test("STT129");
    static STRUCT_IF_C STT129 lv;
    check2(sizeof(lv), 2, "sizeof(STT129)");
    check2(__alignof__(lv), 2, "__alignof__(STT129)");
    check_field_offset(lv, fa, 0, "STT129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT129, STT129)
//============================================================================


struct  STT139  {
  short fa;
  unsigned int  :0;
};
//SIG(1 STT139) C1{ Fs Fi:0}



static void Test_STT139()
{
  {
    init_simple_test("STT139");
    static STRUCT_IF_C STT139 lv;
    check2(sizeof(lv), 4, "sizeof(STT139)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT139)");
    check_field_offset(lv, fa, 0, "STT139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT139, STT139)
//============================================================================


struct  STT149  {
  short fa;
  __tsu64  :0;
};
//SIG(1 STT149) C1{ Fs FL:0}



static void Test_STT149()
{
  {
    init_simple_test("STT149");
    static STRUCT_IF_C STT149 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT149)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT149)");
    check_field_offset(lv, fa, 0, "STT149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT149, STT149)
//============================================================================


struct  STT159  {
  short fa;
  unsigned char  :3;
};
//SIG(1 STT159) C1{ Fs Fc:3}



static void Test_STT159()
{
  {
    init_simple_test("STT159");
    static STRUCT_IF_C STT159 lv;
    check2(sizeof(lv), 4, "sizeof(STT159)");
    check2(__alignof__(lv), 2, "__alignof__(STT159)");
    check_field_offset(lv, fa, 0, "STT159.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT159, STT159)
//============================================================================


struct  STT169  {
  short fa;
  unsigned short  :3;
};
//SIG(1 STT169) C1{ Fs Fs:3}



static void Test_STT169()
{
  {
    init_simple_test("STT169");
    static STRUCT_IF_C STT169 lv;
    check2(sizeof(lv), 4, "sizeof(STT169)");
    check2(__alignof__(lv), 2, "__alignof__(STT169)");
    check_field_offset(lv, fa, 0, "STT169.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT169, STT169)
//============================================================================


struct  STT179  {
  short fa;
  unsigned int  :3;
};
//SIG(1 STT179) C1{ Fs Fi:3}



static void Test_STT179()
{
  {
    init_simple_test("STT179");
    static STRUCT_IF_C STT179 lv;
    check2(sizeof(lv), 4, "sizeof(STT179)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT179)");
    check_field_offset(lv, fa, 0, "STT179.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT179, STT179)
//============================================================================


struct  STT189  {
  short fa;
  __tsu64  :3;
};
//SIG(1 STT189) C1{ Fs FL:3}



static void Test_STT189()
{
  {
    init_simple_test("STT189");
    static STRUCT_IF_C STT189 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT189)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT189)");
    check_field_offset(lv, fa, 0, "STT189.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT189, STT189)
//============================================================================


struct  STT199  {
  short fa;
  unsigned short  :8;
};
//SIG(1 STT199) C1{ Fs Fs:8}



static void Test_STT199()
{
  {
    init_simple_test("STT199");
    static STRUCT_IF_C STT199 lv;
    check2(sizeof(lv), 4, "sizeof(STT199)");
    check2(__alignof__(lv), 2, "__alignof__(STT199)");
    check_field_offset(lv, fa, 0, "STT199.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT199, STT199)
//============================================================================


struct  STT1109  {
  short fa;
  unsigned int  :8;
};
//SIG(1 STT1109) C1{ Fs Fi:8}



static void Test_STT1109()
{
  {
    init_simple_test("STT1109");
    static STRUCT_IF_C STT1109 lv;
    check2(sizeof(lv), 4, "sizeof(STT1109)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1109)");
    check_field_offset(lv, fa, 0, "STT1109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1109, STT1109)
//============================================================================


struct  STT1119  {
  short fa;
  __tsu64  :8;
};
//SIG(1 STT1119) C1{ Fs FL:8}



static void Test_STT1119()
{
  {
    init_simple_test("STT1119");
    static STRUCT_IF_C STT1119 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT1119)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1119)");
    check_field_offset(lv, fa, 0, "STT1119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1119, STT1119)
//============================================================================


struct  STT1129  {
  short fa;
  unsigned int  :18;
};
//SIG(1 STT1129) C1{ Fs Fi:18}



static void Test_STT1129()
{
  {
    init_simple_test("STT1129");
    static STRUCT_IF_C STT1129 lv;
    check2(sizeof(lv), 8, "sizeof(STT1129)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1129)");
    check_field_offset(lv, fa, 0, "STT1129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1129, STT1129)
//============================================================================


struct  STT1139  {
  short fa;
  __tsu64  :18;
};
//SIG(1 STT1139) C1{ Fs FL:18}



static void Test_STT1139()
{
  {
    init_simple_test("STT1139");
    static STRUCT_IF_C STT1139 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT1139)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1139)");
    check_field_offset(lv, fa, 0, "STT1139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1139, STT1139)
//============================================================================


struct  STT1149  {
  short fa;
  __tsu64  :48;
};
//SIG(1 STT1149) C1{ Fs FL:48}



static void Test_STT1149()
{
  {
    init_simple_test("STT1149");
    static STRUCT_IF_C STT1149 lv;
    check2(sizeof(lv), 8, "sizeof(STT1149)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT1149)");
    check_field_offset(lv, fa, 0, "STT1149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1149, STT1149)
//============================================================================


struct  STT1159  {
  short fa;
  unsigned char bf:3;
};
//SIG(1 STT1159) C1{ Fs Fc:3}



static void Test_STT1159()
{
  {
    init_simple_test("STT1159");
    static STRUCT_IF_C STT1159 lv;
    check2(sizeof(lv), 4, "sizeof(STT1159)");
    check2(__alignof__(lv), 2, "__alignof__(STT1159)");
    check_field_offset(lv, fa, 0, "STT1159.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1159");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1159, STT1159)
//============================================================================


struct  STT1169  {
  short fa;
  unsigned short bf:3;
};
//SIG(1 STT1169) C1{ Fs Fs:3}



static void Test_STT1169()
{
  {
    init_simple_test("STT1169");
    static STRUCT_IF_C STT1169 lv;
    check2(sizeof(lv), 4, "sizeof(STT1169)");
    check2(__alignof__(lv), 2, "__alignof__(STT1169)");
    check_field_offset(lv, fa, 0, "STT1169.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1169");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1169, STT1169)
//============================================================================


struct  STT1179  {
  short fa;
  unsigned int bf:3;
};
//SIG(1 STT1179) C1{ Fs Fi:3}



static void Test_STT1179()
{
  {
    init_simple_test("STT1179");
    static STRUCT_IF_C STT1179 lv;
    check2(sizeof(lv), 4, "sizeof(STT1179)");
    check2(__alignof__(lv), 4, "__alignof__(STT1179)");
    check_field_offset(lv, fa, 0, "STT1179.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1179");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1179, STT1179)
//============================================================================


struct  STT1189  {
  short fa;
  __tsu64 bf:3;
};
//SIG(1 STT1189) C1{ Fs FL:3}



static void Test_STT1189()
{
  {
    init_simple_test("STT1189");
    static STRUCT_IF_C STT1189 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT1189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1189)");
    check_field_offset(lv, fa, 0, "STT1189.fa");
    set_bf_and_test(lv, bf, 2, 0, 3, 1, "STT1189");
    set_bf_and_test(lv, bf, 2, 0, 3, hide_ull(1LL<<2), "STT1189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1189, STT1189)
//============================================================================


struct  STT1199  {
  short fa;
  unsigned short bf:8;
};
//SIG(1 STT1199) C1{ Fs Fs:8}



static void Test_STT1199()
{
  {
    init_simple_test("STT1199");
    static STRUCT_IF_C STT1199 lv;
    check2(sizeof(lv), 4, "sizeof(STT1199)");
    check2(__alignof__(lv), 2, "__alignof__(STT1199)");
    check_field_offset(lv, fa, 0, "STT1199.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1199");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1199, STT1199)
//============================================================================


struct  STT1209  {
  short fa;
  unsigned int bf:8;
};
//SIG(1 STT1209) C1{ Fs Fi:8}



static void Test_STT1209()
{
  {
    init_simple_test("STT1209");
    static STRUCT_IF_C STT1209 lv;
    check2(sizeof(lv), 4, "sizeof(STT1209)");
    check2(__alignof__(lv), 4, "__alignof__(STT1209)");
    check_field_offset(lv, fa, 0, "STT1209.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1209");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1209, STT1209)
//============================================================================


struct  STT1219  {
  short fa;
  __tsu64 bf:8;
};
//SIG(1 STT1219) C1{ Fs FL:8}



static void Test_STT1219()
{
  {
    init_simple_test("STT1219");
    static STRUCT_IF_C STT1219 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT1219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1219)");
    check_field_offset(lv, fa, 0, "STT1219.fa");
    set_bf_and_test(lv, bf, 2, 0, 8, 1, "STT1219");
    set_bf_and_test(lv, bf, 2, 0, 8, hide_ull(1LL<<7), "STT1219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1219, STT1219)
//============================================================================


struct  STT1229  {
  short fa;
  unsigned int bf:18;
};
//SIG(1 STT1229) C1{ Fs Fi:18}



static void Test_STT1229()
{
  {
    init_simple_test("STT1229");
    static STRUCT_IF_C STT1229 lv;
    check2(sizeof(lv), 8, "sizeof(STT1229)");
    check2(__alignof__(lv), 4, "__alignof__(STT1229)");
    check_field_offset(lv, fa, 0, "STT1229.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT1229");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT1229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1229, STT1229)
//============================================================================


struct  STT1239  {
  short fa;
  __tsu64 bf:18;
};
//SIG(1 STT1239) C1{ Fs FL:18}



static void Test_STT1239()
{
  {
    init_simple_test("STT1239");
    static STRUCT_IF_C STT1239 lv;
    check2(sizeof(lv), 8, "sizeof(STT1239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1239)");
    check_field_offset(lv, fa, 0, "STT1239.fa");
    set_bf_and_test(lv, bf, 2, 0, 18, 1, "STT1239");
    set_bf_and_test(lv, bf, 2, 0, 18, hide_ull(1LL<<17), "STT1239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1239, STT1239)
//============================================================================


struct  STT1249  {
  short fa;
  __tsu64 bf:48;
};
//SIG(1 STT1249) C1{ Fs FL:48}



static void Test_STT1249()
{
  {
    init_simple_test("STT1249");
    static STRUCT_IF_C STT1249 lv;
    check2(sizeof(lv), 8, "sizeof(STT1249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT1249)");
    check_field_offset(lv, fa, 0, "STT1249.fa");
    set_bf_and_test(lv, bf, 2, 0, 48, 1, "STT1249");
    set_bf_and_test(lv, bf, 2, 0, 48, hide_ull(1LL<<47), "STT1249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT1249, STT1249)
//============================================================================


struct  STT210  {
  int fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT210) C1{ Fi Fc:0 Fc}



static void Test_STT210()
{
  {
    init_simple_test("STT210");
    static STRUCT_IF_C STT210 lv;
    check2(sizeof(lv), 8, "sizeof(STT210)");
    check2(__alignof__(lv), 4, "__alignof__(STT210)");
    check_field_offset(lv, fa, 0, "STT210.fa");
    check_field_offset(lv, fb, 4, "STT210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT210, STT210)
//============================================================================


struct  STT220  {
  int fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT220) C1{ Fi Fs:0 Fc}



static void Test_STT220()
{
  {
    init_simple_test("STT220");
    static STRUCT_IF_C STT220 lv;
    check2(sizeof(lv), 8, "sizeof(STT220)");
    check2(__alignof__(lv), 4, "__alignof__(STT220)");
    check_field_offset(lv, fa, 0, "STT220.fa");
    check_field_offset(lv, fb, 4, "STT220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT220, STT220)
//============================================================================


struct  STT230  {
  int fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT230) C1{ Fi Fi:0 Fc}



static void Test_STT230()
{
  {
    init_simple_test("STT230");
    static STRUCT_IF_C STT230 lv;
    check2(sizeof(lv), 8, "sizeof(STT230)");
    check2(__alignof__(lv), 4, "__alignof__(STT230)");
    check_field_offset(lv, fa, 0, "STT230.fa");
    check_field_offset(lv, fb, 4, "STT230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT230, STT230)
//============================================================================


struct  STT240  {
  int fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT240) C1{ Fi FL:0 Fc}



static void Test_STT240()
{
  {
    init_simple_test("STT240");
    static STRUCT_IF_C STT240 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT240)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT240)");
    check_field_offset(lv, fa, 0, "STT240.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT240, STT240)
//============================================================================


struct  STT250  {
  int fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT250) C1{ Fi Fc:3 Fc}



static void Test_STT250()
{
  {
    init_simple_test("STT250");
    static STRUCT_IF_C STT250 lv;
    check2(sizeof(lv), 8, "sizeof(STT250)");
    check2(__alignof__(lv), 4, "__alignof__(STT250)");
    check_field_offset(lv, fa, 0, "STT250.fa");
    check_field_offset(lv, fb, 5, "STT250.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT250, STT250)
//============================================================================


struct  STT260  {
  int fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT260) C1{ Fi Fs:3 Fc}



static void Test_STT260()
{
  {
    init_simple_test("STT260");
    static STRUCT_IF_C STT260 lv;
    check2(sizeof(lv), 8, "sizeof(STT260)");
    check2(__alignof__(lv), 4, "__alignof__(STT260)");
    check_field_offset(lv, fa, 0, "STT260.fa");
    check_field_offset(lv, fb, 5, "STT260.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT260, STT260)
//============================================================================


struct  STT270  {
  int fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT270) C1{ Fi Fi:3 Fc}



static void Test_STT270()
{
  {
    init_simple_test("STT270");
    static STRUCT_IF_C STT270 lv;
    check2(sizeof(lv), 8, "sizeof(STT270)");
    check2(__alignof__(lv), 4, "__alignof__(STT270)");
    check_field_offset(lv, fa, 0, "STT270.fa");
    check_field_offset(lv, fb, 5, "STT270.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT270, STT270)
//============================================================================


struct  STT280  {
  int fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT280) C1{ Fi FL:3 Fc}



static void Test_STT280()
{
  {
    init_simple_test("STT280");
    static STRUCT_IF_C STT280 lv;
    check2(sizeof(lv), 8, "sizeof(STT280)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT280)");
    check_field_offset(lv, fa, 0, "STT280.fa");
    check_field_offset(lv, fb, 5, "STT280.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT280, STT280)
//============================================================================


struct  STT290  {
  int fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT290) C1{ Fi Fs:8 Fc}



static void Test_STT290()
{
  {
    init_simple_test("STT290");
    static STRUCT_IF_C STT290 lv;
    check2(sizeof(lv), 8, "sizeof(STT290)");
    check2(__alignof__(lv), 4, "__alignof__(STT290)");
    check_field_offset(lv, fa, 0, "STT290.fa");
    check_field_offset(lv, fb, 5, "STT290.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT290, STT290)
//============================================================================


struct  STT2100  {
  int fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT2100) C1{ Fi Fi:8 Fc}



static void Test_STT2100()
{
  {
    init_simple_test("STT2100");
    static STRUCT_IF_C STT2100 lv;
    check2(sizeof(lv), 8, "sizeof(STT2100)");
    check2(__alignof__(lv), 4, "__alignof__(STT2100)");
    check_field_offset(lv, fa, 0, "STT2100.fa");
    check_field_offset(lv, fb, 5, "STT2100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2100, STT2100)
//============================================================================


struct  STT2110  {
  int fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT2110) C1{ Fi FL:8 Fc}



static void Test_STT2110()
{
  {
    init_simple_test("STT2110");
    static STRUCT_IF_C STT2110 lv;
    check2(sizeof(lv), 8, "sizeof(STT2110)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2110)");
    check_field_offset(lv, fa, 0, "STT2110.fa");
    check_field_offset(lv, fb, 5, "STT2110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2110, STT2110)
//============================================================================


struct  STT2120  {
  int fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT2120) C1{ Fi Fi:18 Fc}



static void Test_STT2120()
{
  {
    init_simple_test("STT2120");
    static STRUCT_IF_C STT2120 lv;
    check2(sizeof(lv), 8, "sizeof(STT2120)");
    check2(__alignof__(lv), 4, "__alignof__(STT2120)");
    check_field_offset(lv, fa, 0, "STT2120.fa");
    check_field_offset(lv, fb, 7, "STT2120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2120, STT2120)
//============================================================================


struct  STT2130  {
  int fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT2130) C1{ Fi FL:18 Fc}



static void Test_STT2130()
{
  {
    init_simple_test("STT2130");
    static STRUCT_IF_C STT2130 lv;
    check2(sizeof(lv), 8, "sizeof(STT2130)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2130)");
    check_field_offset(lv, fa, 0, "STT2130.fa");
    check_field_offset(lv, fb, 7, "STT2130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2130, STT2130)
//============================================================================


struct  STT2140  {
  int fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT2140) C1{ Fi FL:48 Fc}



static void Test_STT2140()
{
  {
    init_simple_test("STT2140");
    static STRUCT_IF_C STT2140 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2140)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2140)");
    check_field_offset(lv, fa, 0, "STT2140.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT2140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2140, STT2140)
//============================================================================


struct  STT2150  {
  int fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT2150) C1{ Fi Fc:3 Fc}



static void Test_STT2150()
{
  {
    init_simple_test("STT2150");
    static STRUCT_IF_C STT2150 lv;
    check2(sizeof(lv), 8, "sizeof(STT2150)");
    check2(__alignof__(lv), 4, "__alignof__(STT2150)");
    check_field_offset(lv, fa, 0, "STT2150.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2150");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2150");
    check_field_offset(lv, fb, 5, "STT2150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2150, STT2150)
//============================================================================


struct  STT2160  {
  int fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT2160) C1{ Fi Fs:3 Fc}



static void Test_STT2160()
{
  {
    init_simple_test("STT2160");
    static STRUCT_IF_C STT2160 lv;
    check2(sizeof(lv), 8, "sizeof(STT2160)");
    check2(__alignof__(lv), 4, "__alignof__(STT2160)");
    check_field_offset(lv, fa, 0, "STT2160.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2160");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2160");
    check_field_offset(lv, fb, 5, "STT2160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2160, STT2160)
//============================================================================


struct  STT2170  {
  int fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT2170) C1{ Fi Fi:3 Fc}



static void Test_STT2170()
{
  {
    init_simple_test("STT2170");
    static STRUCT_IF_C STT2170 lv;
    check2(sizeof(lv), 8, "sizeof(STT2170)");
    check2(__alignof__(lv), 4, "__alignof__(STT2170)");
    check_field_offset(lv, fa, 0, "STT2170.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2170");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2170");
    check_field_offset(lv, fb, 5, "STT2170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2170, STT2170)
//============================================================================


struct  STT2180  {
  int fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT2180) C1{ Fi FL:3 Fc}



static void Test_STT2180()
{
  {
    init_simple_test("STT2180");
    static STRUCT_IF_C STT2180 lv;
    check2(sizeof(lv), 8, "sizeof(STT2180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2180)");
    check_field_offset(lv, fa, 0, "STT2180.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2180");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2180");
    check_field_offset(lv, fb, 5, "STT2180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2180, STT2180)
//============================================================================


struct  STT2190  {
  int fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT2190) C1{ Fi Fs:8 Fc}



static void Test_STT2190()
{
  {
    init_simple_test("STT2190");
    static STRUCT_IF_C STT2190 lv;
    check2(sizeof(lv), 8, "sizeof(STT2190)");
    check2(__alignof__(lv), 4, "__alignof__(STT2190)");
    check_field_offset(lv, fa, 0, "STT2190.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2190");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2190");
    check_field_offset(lv, fb, 5, "STT2190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2190, STT2190)
//============================================================================


struct  STT2200  {
  int fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT2200) C1{ Fi Fi:8 Fc}



static void Test_STT2200()
{
  {
    init_simple_test("STT2200");
    static STRUCT_IF_C STT2200 lv;
    check2(sizeof(lv), 8, "sizeof(STT2200)");
    check2(__alignof__(lv), 4, "__alignof__(STT2200)");
    check_field_offset(lv, fa, 0, "STT2200.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2200");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2200");
    check_field_offset(lv, fb, 5, "STT2200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2200, STT2200)
//============================================================================


struct  STT2210  {
  int fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT2210) C1{ Fi FL:8 Fc}



static void Test_STT2210()
{
  {
    init_simple_test("STT2210");
    static STRUCT_IF_C STT2210 lv;
    check2(sizeof(lv), 8, "sizeof(STT2210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2210)");
    check_field_offset(lv, fa, 0, "STT2210.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2210");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2210");
    check_field_offset(lv, fb, 5, "STT2210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2210, STT2210)
//============================================================================


struct  STT2220  {
  int fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT2220) C1{ Fi Fi:18 Fc}



static void Test_STT2220()
{
  {
    init_simple_test("STT2220");
    static STRUCT_IF_C STT2220 lv;
    check2(sizeof(lv), 8, "sizeof(STT2220)");
    check2(__alignof__(lv), 4, "__alignof__(STT2220)");
    check_field_offset(lv, fa, 0, "STT2220.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2220");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2220");
    check_field_offset(lv, fb, 7, "STT2220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2220, STT2220)
//============================================================================


struct  STT2230  {
  int fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT2230) C1{ Fi FL:18 Fc}



static void Test_STT2230()
{
  {
    init_simple_test("STT2230");
    static STRUCT_IF_C STT2230 lv;
    check2(sizeof(lv), 8, "sizeof(STT2230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2230)");
    check_field_offset(lv, fa, 0, "STT2230.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2230");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2230");
    check_field_offset(lv, fb, 7, "STT2230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2230, STT2230)
//============================================================================


struct  STT2240  {
  int fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT2240) C1{ Fi FL:48 Fc}



static void Test_STT2240()
{
  {
    init_simple_test("STT2240");
    static STRUCT_IF_C STT2240 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2240)");
    check_field_offset(lv, fa, 0, "STT2240.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2240");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2240");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT2240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2240, STT2240)
//============================================================================


struct  STT211  {
  int fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT211) C1{ Fi Fc:0 Fs}



static void Test_STT211()
{
  {
    init_simple_test("STT211");
    static STRUCT_IF_C STT211 lv;
    check2(sizeof(lv), 8, "sizeof(STT211)");
    check2(__alignof__(lv), 4, "__alignof__(STT211)");
    check_field_offset(lv, fa, 0, "STT211.fa");
    check_field_offset(lv, fb, 4, "STT211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT211, STT211)
//============================================================================


struct  STT221  {
  int fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT221) C1{ Fi Fs:0 Fs}



static void Test_STT221()
{
  {
    init_simple_test("STT221");
    static STRUCT_IF_C STT221 lv;
    check2(sizeof(lv), 8, "sizeof(STT221)");
    check2(__alignof__(lv), 4, "__alignof__(STT221)");
    check_field_offset(lv, fa, 0, "STT221.fa");
    check_field_offset(lv, fb, 4, "STT221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT221, STT221)
//============================================================================


struct  STT231  {
  int fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT231) C1{ Fi Fi:0 Fs}



static void Test_STT231()
{
  {
    init_simple_test("STT231");
    static STRUCT_IF_C STT231 lv;
    check2(sizeof(lv), 8, "sizeof(STT231)");
    check2(__alignof__(lv), 4, "__alignof__(STT231)");
    check_field_offset(lv, fa, 0, "STT231.fa");
    check_field_offset(lv, fb, 4, "STT231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT231, STT231)
//============================================================================


struct  STT241  {
  int fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT241) C1{ Fi FL:0 Fs}



static void Test_STT241()
{
  {
    init_simple_test("STT241");
    static STRUCT_IF_C STT241 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT241)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT241)");
    check_field_offset(lv, fa, 0, "STT241.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT241, STT241)
//============================================================================


struct  STT251  {
  int fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT251) C1{ Fi Fc:3 Fs}



static void Test_STT251()
{
  {
    init_simple_test("STT251");
    static STRUCT_IF_C STT251 lv;
    check2(sizeof(lv), 8, "sizeof(STT251)");
    check2(__alignof__(lv), 4, "__alignof__(STT251)");
    check_field_offset(lv, fa, 0, "STT251.fa");
    check_field_offset(lv, fb, 6, "STT251.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT251, STT251)
//============================================================================


struct  STT261  {
  int fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT261) C1{ Fi Fs:3 Fs}



static void Test_STT261()
{
  {
    init_simple_test("STT261");
    static STRUCT_IF_C STT261 lv;
    check2(sizeof(lv), 8, "sizeof(STT261)");
    check2(__alignof__(lv), 4, "__alignof__(STT261)");
    check_field_offset(lv, fa, 0, "STT261.fa");
    check_field_offset(lv, fb, 6, "STT261.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT261, STT261)
//============================================================================


struct  STT271  {
  int fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT271) C1{ Fi Fi:3 Fs}



static void Test_STT271()
{
  {
    init_simple_test("STT271");
    static STRUCT_IF_C STT271 lv;
    check2(sizeof(lv), 8, "sizeof(STT271)");
    check2(__alignof__(lv), 4, "__alignof__(STT271)");
    check_field_offset(lv, fa, 0, "STT271.fa");
    check_field_offset(lv, fb, 6, "STT271.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT271, STT271)
//============================================================================


struct  STT281  {
  int fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT281) C1{ Fi FL:3 Fs}



static void Test_STT281()
{
  {
    init_simple_test("STT281");
    static STRUCT_IF_C STT281 lv;
    check2(sizeof(lv), 8, "sizeof(STT281)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT281)");
    check_field_offset(lv, fa, 0, "STT281.fa");
    check_field_offset(lv, fb, 6, "STT281.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT281, STT281)
//============================================================================


struct  STT291  {
  int fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT291) C1{ Fi Fs:8 Fs}



static void Test_STT291()
{
  {
    init_simple_test("STT291");
    static STRUCT_IF_C STT291 lv;
    check2(sizeof(lv), 8, "sizeof(STT291)");
    check2(__alignof__(lv), 4, "__alignof__(STT291)");
    check_field_offset(lv, fa, 0, "STT291.fa");
    check_field_offset(lv, fb, 6, "STT291.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT291, STT291)
//============================================================================


struct  STT2101  {
  int fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT2101) C1{ Fi Fi:8 Fs}



static void Test_STT2101()
{
  {
    init_simple_test("STT2101");
    static STRUCT_IF_C STT2101 lv;
    check2(sizeof(lv), 8, "sizeof(STT2101)");
    check2(__alignof__(lv), 4, "__alignof__(STT2101)");
    check_field_offset(lv, fa, 0, "STT2101.fa");
    check_field_offset(lv, fb, 6, "STT2101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2101, STT2101)
//============================================================================


struct  STT2111  {
  int fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT2111) C1{ Fi FL:8 Fs}



static void Test_STT2111()
{
  {
    init_simple_test("STT2111");
    static STRUCT_IF_C STT2111 lv;
    check2(sizeof(lv), 8, "sizeof(STT2111)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2111)");
    check_field_offset(lv, fa, 0, "STT2111.fa");
    check_field_offset(lv, fb, 6, "STT2111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2111, STT2111)
//============================================================================


struct  STT2121  {
  int fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT2121) C1{ Fi Fi:18 Fs}



static void Test_STT2121()
{
  {
    init_simple_test("STT2121");
    static STRUCT_IF_C STT2121 lv;
    check2(sizeof(lv), 12, "sizeof(STT2121)");
    check2(__alignof__(lv), 4, "__alignof__(STT2121)");
    check_field_offset(lv, fa, 0, "STT2121.fa");
    check_field_offset(lv, fb, 8, "STT2121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2121, STT2121)
//============================================================================


struct  STT2131  {
  int fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT2131) C1{ Fi FL:18 Fs}



static void Test_STT2131()
{
  {
    init_simple_test("STT2131");
    static STRUCT_IF_C STT2131 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT2131)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2131)");
    check_field_offset(lv, fa, 0, "STT2131.fa");
    check_field_offset(lv, fb, 8, "STT2131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2131, STT2131)
//============================================================================


struct  STT2141  {
  int fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT2141) C1{ Fi FL:48 Fs}



static void Test_STT2141()
{
  {
    init_simple_test("STT2141");
    static STRUCT_IF_C STT2141 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2141)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2141)");
    check_field_offset(lv, fa, 0, "STT2141.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT2141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2141, STT2141)
//============================================================================


struct  STT2151  {
  int fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT2151) C1{ Fi Fc:3 Fs}



static void Test_STT2151()
{
  {
    init_simple_test("STT2151");
    static STRUCT_IF_C STT2151 lv;
    check2(sizeof(lv), 8, "sizeof(STT2151)");
    check2(__alignof__(lv), 4, "__alignof__(STT2151)");
    check_field_offset(lv, fa, 0, "STT2151.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2151");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2151");
    check_field_offset(lv, fb, 6, "STT2151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2151, STT2151)
//============================================================================


struct  STT2161  {
  int fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT2161) C1{ Fi Fs:3 Fs}



static void Test_STT2161()
{
  {
    init_simple_test("STT2161");
    static STRUCT_IF_C STT2161 lv;
    check2(sizeof(lv), 8, "sizeof(STT2161)");
    check2(__alignof__(lv), 4, "__alignof__(STT2161)");
    check_field_offset(lv, fa, 0, "STT2161.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2161");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2161");
    check_field_offset(lv, fb, 6, "STT2161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2161, STT2161)
//============================================================================


struct  STT2171  {
  int fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT2171) C1{ Fi Fi:3 Fs}



static void Test_STT2171()
{
  {
    init_simple_test("STT2171");
    static STRUCT_IF_C STT2171 lv;
    check2(sizeof(lv), 8, "sizeof(STT2171)");
    check2(__alignof__(lv), 4, "__alignof__(STT2171)");
    check_field_offset(lv, fa, 0, "STT2171.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2171");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2171");
    check_field_offset(lv, fb, 6, "STT2171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2171, STT2171)
//============================================================================


struct  STT2181  {
  int fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT2181) C1{ Fi FL:3 Fs}



static void Test_STT2181()
{
  {
    init_simple_test("STT2181");
    static STRUCT_IF_C STT2181 lv;
    check2(sizeof(lv), 8, "sizeof(STT2181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2181)");
    check_field_offset(lv, fa, 0, "STT2181.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2181");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2181");
    check_field_offset(lv, fb, 6, "STT2181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2181, STT2181)
//============================================================================


struct  STT2191  {
  int fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT2191) C1{ Fi Fs:8 Fs}



static void Test_STT2191()
{
  {
    init_simple_test("STT2191");
    static STRUCT_IF_C STT2191 lv;
    check2(sizeof(lv), 8, "sizeof(STT2191)");
    check2(__alignof__(lv), 4, "__alignof__(STT2191)");
    check_field_offset(lv, fa, 0, "STT2191.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2191");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2191");
    check_field_offset(lv, fb, 6, "STT2191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2191, STT2191)
//============================================================================


struct  STT2201  {
  int fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT2201) C1{ Fi Fi:8 Fs}



static void Test_STT2201()
{
  {
    init_simple_test("STT2201");
    static STRUCT_IF_C STT2201 lv;
    check2(sizeof(lv), 8, "sizeof(STT2201)");
    check2(__alignof__(lv), 4, "__alignof__(STT2201)");
    check_field_offset(lv, fa, 0, "STT2201.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2201");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2201");
    check_field_offset(lv, fb, 6, "STT2201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2201, STT2201)
//============================================================================


struct  STT2211  {
  int fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT2211) C1{ Fi FL:8 Fs}



static void Test_STT2211()
{
  {
    init_simple_test("STT2211");
    static STRUCT_IF_C STT2211 lv;
    check2(sizeof(lv), 8, "sizeof(STT2211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2211)");
    check_field_offset(lv, fa, 0, "STT2211.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2211");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2211");
    check_field_offset(lv, fb, 6, "STT2211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2211, STT2211)
//============================================================================


struct  STT2221  {
  int fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT2221) C1{ Fi Fi:18 Fs}



static void Test_STT2221()
{
  {
    init_simple_test("STT2221");
    static STRUCT_IF_C STT2221 lv;
    check2(sizeof(lv), 12, "sizeof(STT2221)");
    check2(__alignof__(lv), 4, "__alignof__(STT2221)");
    check_field_offset(lv, fa, 0, "STT2221.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2221");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2221");
    check_field_offset(lv, fb, 8, "STT2221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2221, STT2221)
//============================================================================


struct  STT2231  {
  int fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT2231) C1{ Fi FL:18 Fs}



static void Test_STT2231()
{
  {
    init_simple_test("STT2231");
    static STRUCT_IF_C STT2231 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2231)");
    check_field_offset(lv, fa, 0, "STT2231.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2231");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2231");
    check_field_offset(lv, fb, 8, "STT2231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2231, STT2231)
//============================================================================


struct  STT2241  {
  int fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT2241) C1{ Fi FL:48 Fs}



static void Test_STT2241()
{
  {
    init_simple_test("STT2241");
    static STRUCT_IF_C STT2241 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2241)");
    check_field_offset(lv, fa, 0, "STT2241.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2241");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2241");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT2241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2241, STT2241)
//============================================================================


struct  STT212  {
  int fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT212) C1{ Fi Fc:0 Fi}



static void Test_STT212()
{
  {
    init_simple_test("STT212");
    static STRUCT_IF_C STT212 lv;
    check2(sizeof(lv), 8, "sizeof(STT212)");
    check2(__alignof__(lv), 4, "__alignof__(STT212)");
    check_field_offset(lv, fa, 0, "STT212.fa");
    check_field_offset(lv, fb, 4, "STT212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT212, STT212)
//============================================================================


struct  STT222  {
  int fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT222) C1{ Fi Fs:0 Fi}



static void Test_STT222()
{
  {
    init_simple_test("STT222");
    static STRUCT_IF_C STT222 lv;
    check2(sizeof(lv), 8, "sizeof(STT222)");
    check2(__alignof__(lv), 4, "__alignof__(STT222)");
    check_field_offset(lv, fa, 0, "STT222.fa");
    check_field_offset(lv, fb, 4, "STT222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT222, STT222)
//============================================================================


struct  STT232  {
  int fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT232) C1{ Fi Fi:0 Fi}



static void Test_STT232()
{
  {
    init_simple_test("STT232");
    static STRUCT_IF_C STT232 lv;
    check2(sizeof(lv), 8, "sizeof(STT232)");
    check2(__alignof__(lv), 4, "__alignof__(STT232)");
    check_field_offset(lv, fa, 0, "STT232.fa");
    check_field_offset(lv, fb, 4, "STT232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT232, STT232)
//============================================================================


struct  STT242  {
  int fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT242) C1{ Fi FL:0 Fi}



static void Test_STT242()
{
  {
    init_simple_test("STT242");
    static STRUCT_IF_C STT242 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT242)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT242)");
    check_field_offset(lv, fa, 0, "STT242.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT242, STT242)
//============================================================================


struct  STT252  {
  int fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT252) C1{ Fi Fc:3 Fi}



static void Test_STT252()
{
  {
    init_simple_test("STT252");
    static STRUCT_IF_C STT252 lv;
    check2(sizeof(lv), 12, "sizeof(STT252)");
    check2(__alignof__(lv), 4, "__alignof__(STT252)");
    check_field_offset(lv, fa, 0, "STT252.fa");
    check_field_offset(lv, fb, 8, "STT252.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT252, STT252)
//============================================================================


struct  STT262  {
  int fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT262) C1{ Fi Fs:3 Fi}



static void Test_STT262()
{
  {
    init_simple_test("STT262");
    static STRUCT_IF_C STT262 lv;
    check2(sizeof(lv), 12, "sizeof(STT262)");
    check2(__alignof__(lv), 4, "__alignof__(STT262)");
    check_field_offset(lv, fa, 0, "STT262.fa");
    check_field_offset(lv, fb, 8, "STT262.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT262, STT262)
//============================================================================


struct  STT272  {
  int fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT272) C1{ Fi Fi:3 Fi}



static void Test_STT272()
{
  {
    init_simple_test("STT272");
    static STRUCT_IF_C STT272 lv;
    check2(sizeof(lv), 12, "sizeof(STT272)");
    check2(__alignof__(lv), 4, "__alignof__(STT272)");
    check_field_offset(lv, fa, 0, "STT272.fa");
    check_field_offset(lv, fb, 8, "STT272.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT272, STT272)
//============================================================================


struct  STT282  {
  int fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT282) C1{ Fi FL:3 Fi}



static void Test_STT282()
{
  {
    init_simple_test("STT282");
    static STRUCT_IF_C STT282 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT282)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT282)");
    check_field_offset(lv, fa, 0, "STT282.fa");
    check_field_offset(lv, fb, 8, "STT282.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT282, STT282)
//============================================================================


struct  STT292  {
  int fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT292) C1{ Fi Fs:8 Fi}



static void Test_STT292()
{
  {
    init_simple_test("STT292");
    static STRUCT_IF_C STT292 lv;
    check2(sizeof(lv), 12, "sizeof(STT292)");
    check2(__alignof__(lv), 4, "__alignof__(STT292)");
    check_field_offset(lv, fa, 0, "STT292.fa");
    check_field_offset(lv, fb, 8, "STT292.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT292, STT292)
//============================================================================


struct  STT2102  {
  int fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT2102) C1{ Fi Fi:8 Fi}



static void Test_STT2102()
{
  {
    init_simple_test("STT2102");
    static STRUCT_IF_C STT2102 lv;
    check2(sizeof(lv), 12, "sizeof(STT2102)");
    check2(__alignof__(lv), 4, "__alignof__(STT2102)");
    check_field_offset(lv, fa, 0, "STT2102.fa");
    check_field_offset(lv, fb, 8, "STT2102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2102, STT2102)
//============================================================================


struct  STT2112  {
  int fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT2112) C1{ Fi FL:8 Fi}



static void Test_STT2112()
{
  {
    init_simple_test("STT2112");
    static STRUCT_IF_C STT2112 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT2112)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2112)");
    check_field_offset(lv, fa, 0, "STT2112.fa");
    check_field_offset(lv, fb, 8, "STT2112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2112, STT2112)
//============================================================================


struct  STT2122  {
  int fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT2122) C1{ Fi Fi:18 Fi}



static void Test_STT2122()
{
  {
    init_simple_test("STT2122");
    static STRUCT_IF_C STT2122 lv;
    check2(sizeof(lv), 12, "sizeof(STT2122)");
    check2(__alignof__(lv), 4, "__alignof__(STT2122)");
    check_field_offset(lv, fa, 0, "STT2122.fa");
    check_field_offset(lv, fb, 8, "STT2122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2122, STT2122)
//============================================================================


struct  STT2132  {
  int fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT2132) C1{ Fi FL:18 Fi}



static void Test_STT2132()
{
  {
    init_simple_test("STT2132");
    static STRUCT_IF_C STT2132 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT2132)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2132)");
    check_field_offset(lv, fa, 0, "STT2132.fa");
    check_field_offset(lv, fb, 8, "STT2132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2132, STT2132)
//============================================================================


struct  STT2142  {
  int fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT2142) C1{ Fi FL:48 Fi}



static void Test_STT2142()
{
  {
    init_simple_test("STT2142");
    static STRUCT_IF_C STT2142 lv;
    check2(sizeof(lv), ABISELECT(20,16), "sizeof(STT2142)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2142)");
    check_field_offset(lv, fa, 0, "STT2142.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2142, STT2142)
//============================================================================


struct  STT2152  {
  int fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT2152) C1{ Fi Fc:3 Fi}



static void Test_STT2152()
{
  {
    init_simple_test("STT2152");
    static STRUCT_IF_C STT2152 lv;
    check2(sizeof(lv), 12, "sizeof(STT2152)");
    check2(__alignof__(lv), 4, "__alignof__(STT2152)");
    check_field_offset(lv, fa, 0, "STT2152.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2152");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2152");
    check_field_offset(lv, fb, 8, "STT2152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2152, STT2152)
//============================================================================


struct  STT2162  {
  int fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT2162) C1{ Fi Fs:3 Fi}



static void Test_STT2162()
{
  {
    init_simple_test("STT2162");
    static STRUCT_IF_C STT2162 lv;
    check2(sizeof(lv), 12, "sizeof(STT2162)");
    check2(__alignof__(lv), 4, "__alignof__(STT2162)");
    check_field_offset(lv, fa, 0, "STT2162.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2162");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2162");
    check_field_offset(lv, fb, 8, "STT2162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2162, STT2162)
//============================================================================


struct  STT2172  {
  int fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT2172) C1{ Fi Fi:3 Fi}



static void Test_STT2172()
{
  {
    init_simple_test("STT2172");
    static STRUCT_IF_C STT2172 lv;
    check2(sizeof(lv), 12, "sizeof(STT2172)");
    check2(__alignof__(lv), 4, "__alignof__(STT2172)");
    check_field_offset(lv, fa, 0, "STT2172.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2172");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2172");
    check_field_offset(lv, fb, 8, "STT2172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2172, STT2172)
//============================================================================


struct  STT2182  {
  int fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT2182) C1{ Fi FL:3 Fi}



static void Test_STT2182()
{
  {
    init_simple_test("STT2182");
    static STRUCT_IF_C STT2182 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2182)");
    check_field_offset(lv, fa, 0, "STT2182.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2182");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2182");
    check_field_offset(lv, fb, 8, "STT2182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2182, STT2182)
//============================================================================


struct  STT2192  {
  int fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT2192) C1{ Fi Fs:8 Fi}



static void Test_STT2192()
{
  {
    init_simple_test("STT2192");
    static STRUCT_IF_C STT2192 lv;
    check2(sizeof(lv), 12, "sizeof(STT2192)");
    check2(__alignof__(lv), 4, "__alignof__(STT2192)");
    check_field_offset(lv, fa, 0, "STT2192.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2192");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2192");
    check_field_offset(lv, fb, 8, "STT2192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2192, STT2192)
//============================================================================


struct  STT2202  {
  int fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT2202) C1{ Fi Fi:8 Fi}



static void Test_STT2202()
{
  {
    init_simple_test("STT2202");
    static STRUCT_IF_C STT2202 lv;
    check2(sizeof(lv), 12, "sizeof(STT2202)");
    check2(__alignof__(lv), 4, "__alignof__(STT2202)");
    check_field_offset(lv, fa, 0, "STT2202.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2202");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2202");
    check_field_offset(lv, fb, 8, "STT2202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2202, STT2202)
//============================================================================


struct  STT2212  {
  int fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT2212) C1{ Fi FL:8 Fi}



static void Test_STT2212()
{
  {
    init_simple_test("STT2212");
    static STRUCT_IF_C STT2212 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2212)");
    check_field_offset(lv, fa, 0, "STT2212.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2212");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2212");
    check_field_offset(lv, fb, 8, "STT2212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2212, STT2212)
//============================================================================


struct  STT2222  {
  int fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT2222) C1{ Fi Fi:18 Fi}



static void Test_STT2222()
{
  {
    init_simple_test("STT2222");
    static STRUCT_IF_C STT2222 lv;
    check2(sizeof(lv), 12, "sizeof(STT2222)");
    check2(__alignof__(lv), 4, "__alignof__(STT2222)");
    check_field_offset(lv, fa, 0, "STT2222.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2222");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2222");
    check_field_offset(lv, fb, 8, "STT2222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2222, STT2222)
//============================================================================


struct  STT2232  {
  int fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT2232) C1{ Fi FL:18 Fi}



static void Test_STT2232()
{
  {
    init_simple_test("STT2232");
    static STRUCT_IF_C STT2232 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2232)");
    check_field_offset(lv, fa, 0, "STT2232.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2232");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2232");
    check_field_offset(lv, fb, 8, "STT2232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2232, STT2232)
//============================================================================


struct  STT2242  {
  int fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT2242) C1{ Fi FL:48 Fi}



static void Test_STT2242()
{
  {
    init_simple_test("STT2242");
    static STRUCT_IF_C STT2242 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT2242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2242)");
    check_field_offset(lv, fa, 0, "STT2242.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2242");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2242");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2242, STT2242)
//============================================================================


struct  STT213  {
  int fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT213) C1{ Fi Fc:0 Fl}



static void Test_STT213()
{
  {
    init_simple_test("STT213");
    static STRUCT_IF_C STT213 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT213)");
    check_field_offset(lv, fa, 0, "STT213.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT213, STT213)
//============================================================================


struct  STT223  {
  int fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT223) C1{ Fi Fs:0 Fl}



static void Test_STT223()
{
  {
    init_simple_test("STT223");
    static STRUCT_IF_C STT223 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT223)");
    check_field_offset(lv, fa, 0, "STT223.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT223, STT223)
//============================================================================


struct  STT233  {
  int fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT233) C1{ Fi Fi:0 Fl}



static void Test_STT233()
{
  {
    init_simple_test("STT233");
    static STRUCT_IF_C STT233 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT233)");
    check_field_offset(lv, fa, 0, "STT233.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT233, STT233)
//============================================================================


struct  STT243  {
  int fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT243) C1{ Fi FL:0 Fl}



static void Test_STT243()
{
  {
    init_simple_test("STT243");
    static STRUCT_IF_C STT243 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT243)");
    check_field_offset(lv, fa, 0, "STT243.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT243, STT243)
//============================================================================


struct  STT253  {
  int fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT253) C1{ Fi Fc:3 Fl}



static void Test_STT253()
{
  {
    init_simple_test("STT253");
    static STRUCT_IF_C STT253 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT253)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT253)");
    check_field_offset(lv, fa, 0, "STT253.fa");
    check_field_offset(lv, fb, 8, "STT253.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT253, STT253)
//============================================================================


struct  STT263  {
  int fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT263) C1{ Fi Fs:3 Fl}



static void Test_STT263()
{
  {
    init_simple_test("STT263");
    static STRUCT_IF_C STT263 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT263)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT263)");
    check_field_offset(lv, fa, 0, "STT263.fa");
    check_field_offset(lv, fb, 8, "STT263.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT263, STT263)
//============================================================================


struct  STT273  {
  int fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT273) C1{ Fi Fi:3 Fl}



static void Test_STT273()
{
  {
    init_simple_test("STT273");
    static STRUCT_IF_C STT273 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT273)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT273)");
    check_field_offset(lv, fa, 0, "STT273.fa");
    check_field_offset(lv, fb, 8, "STT273.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT273, STT273)
//============================================================================


struct  STT283  {
  int fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT283) C1{ Fi FL:3 Fl}



static void Test_STT283()
{
  {
    init_simple_test("STT283");
    static STRUCT_IF_C STT283 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT283)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT283)");
    check_field_offset(lv, fa, 0, "STT283.fa");
    check_field_offset(lv, fb, 8, "STT283.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT283, STT283)
//============================================================================


struct  STT293  {
  int fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT293) C1{ Fi Fs:8 Fl}



static void Test_STT293()
{
  {
    init_simple_test("STT293");
    static STRUCT_IF_C STT293 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT293)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT293)");
    check_field_offset(lv, fa, 0, "STT293.fa");
    check_field_offset(lv, fb, 8, "STT293.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT293, STT293)
//============================================================================


struct  STT2103  {
  int fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT2103) C1{ Fi Fi:8 Fl}



static void Test_STT2103()
{
  {
    init_simple_test("STT2103");
    static STRUCT_IF_C STT2103 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2103)");
    check_field_offset(lv, fa, 0, "STT2103.fa");
    check_field_offset(lv, fb, 8, "STT2103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2103, STT2103)
//============================================================================


struct  STT2113  {
  int fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT2113) C1{ Fi FL:8 Fl}



static void Test_STT2113()
{
  {
    init_simple_test("STT2113");
    static STRUCT_IF_C STT2113 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2113)");
    check_field_offset(lv, fa, 0, "STT2113.fa");
    check_field_offset(lv, fb, 8, "STT2113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2113, STT2113)
//============================================================================


struct  STT2123  {
  int fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT2123) C1{ Fi Fi:18 Fl}



static void Test_STT2123()
{
  {
    init_simple_test("STT2123");
    static STRUCT_IF_C STT2123 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2123)");
    check_field_offset(lv, fa, 0, "STT2123.fa");
    check_field_offset(lv, fb, 8, "STT2123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2123, STT2123)
//============================================================================


struct  STT2133  {
  int fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT2133) C1{ Fi FL:18 Fl}



static void Test_STT2133()
{
  {
    init_simple_test("STT2133");
    static STRUCT_IF_C STT2133 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2133)");
    check_field_offset(lv, fa, 0, "STT2133.fa");
    check_field_offset(lv, fb, 8, "STT2133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2133, STT2133)
//============================================================================


struct  STT2143  {
  int fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT2143) C1{ Fi FL:48 Fl}



static void Test_STT2143()
{
  {
    init_simple_test("STT2143");
    static STRUCT_IF_C STT2143 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT2143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2143)");
    check_field_offset(lv, fa, 0, "STT2143.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2143, STT2143)
//============================================================================


struct  STT2153  {
  int fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT2153) C1{ Fi Fc:3 Fl}



static void Test_STT2153()
{
  {
    init_simple_test("STT2153");
    static STRUCT_IF_C STT2153 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2153)");
    check_field_offset(lv, fa, 0, "STT2153.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2153");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2153");
    check_field_offset(lv, fb, 8, "STT2153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2153, STT2153)
//============================================================================


struct  STT2163  {
  int fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT2163) C1{ Fi Fs:3 Fl}



static void Test_STT2163()
{
  {
    init_simple_test("STT2163");
    static STRUCT_IF_C STT2163 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2163)");
    check_field_offset(lv, fa, 0, "STT2163.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2163");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2163");
    check_field_offset(lv, fb, 8, "STT2163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2163, STT2163)
//============================================================================


struct  STT2173  {
  int fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT2173) C1{ Fi Fi:3 Fl}



static void Test_STT2173()
{
  {
    init_simple_test("STT2173");
    static STRUCT_IF_C STT2173 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2173)");
    check_field_offset(lv, fa, 0, "STT2173.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2173");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2173");
    check_field_offset(lv, fb, 8, "STT2173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2173, STT2173)
//============================================================================


struct  STT2183  {
  int fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT2183) C1{ Fi FL:3 Fl}



static void Test_STT2183()
{
  {
    init_simple_test("STT2183");
    static STRUCT_IF_C STT2183 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2183)");
    check_field_offset(lv, fa, 0, "STT2183.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2183");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2183");
    check_field_offset(lv, fb, 8, "STT2183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2183, STT2183)
//============================================================================


struct  STT2193  {
  int fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT2193) C1{ Fi Fs:8 Fl}



static void Test_STT2193()
{
  {
    init_simple_test("STT2193");
    static STRUCT_IF_C STT2193 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2193)");
    check_field_offset(lv, fa, 0, "STT2193.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2193");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2193");
    check_field_offset(lv, fb, 8, "STT2193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2193, STT2193)
//============================================================================


struct  STT2203  {
  int fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT2203) C1{ Fi Fi:8 Fl}



static void Test_STT2203()
{
  {
    init_simple_test("STT2203");
    static STRUCT_IF_C STT2203 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2203)");
    check_field_offset(lv, fa, 0, "STT2203.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2203");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2203");
    check_field_offset(lv, fb, 8, "STT2203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2203, STT2203)
//============================================================================


struct  STT2213  {
  int fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT2213) C1{ Fi FL:8 Fl}



static void Test_STT2213()
{
  {
    init_simple_test("STT2213");
    static STRUCT_IF_C STT2213 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2213)");
    check_field_offset(lv, fa, 0, "STT2213.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2213");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2213");
    check_field_offset(lv, fb, 8, "STT2213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2213, STT2213)
//============================================================================


struct  STT2223  {
  int fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT2223) C1{ Fi Fi:18 Fl}



static void Test_STT2223()
{
  {
    init_simple_test("STT2223");
    static STRUCT_IF_C STT2223 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2223)");
    check_field_offset(lv, fa, 0, "STT2223.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2223");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2223");
    check_field_offset(lv, fb, 8, "STT2223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2223, STT2223)
//============================================================================


struct  STT2233  {
  int fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT2233) C1{ Fi FL:18 Fl}



static void Test_STT2233()
{
  {
    init_simple_test("STT2233");
    static STRUCT_IF_C STT2233 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2233)");
    check_field_offset(lv, fa, 0, "STT2233.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2233");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2233");
    check_field_offset(lv, fb, 8, "STT2233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2233, STT2233)
//============================================================================


struct  STT2243  {
  int fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT2243) C1{ Fi FL:48 Fl}



static void Test_STT2243()
{
  {
    init_simple_test("STT2243");
    static STRUCT_IF_C STT2243 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT2243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2243)");
    check_field_offset(lv, fa, 0, "STT2243.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2243");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2243");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2243, STT2243)
//============================================================================


struct  STT214  {
  int fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT214) C1{ Fi Fc:0 FL}



static void Test_STT214()
{
  {
    init_simple_test("STT214");
    static STRUCT_IF_C STT214 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT214)");
    check_field_offset(lv, fa, 0, "STT214.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT214, STT214)
//============================================================================


struct  STT224  {
  int fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT224) C1{ Fi Fs:0 FL}



static void Test_STT224()
{
  {
    init_simple_test("STT224");
    static STRUCT_IF_C STT224 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT224)");
    check_field_offset(lv, fa, 0, "STT224.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT224, STT224)
//============================================================================


struct  STT234  {
  int fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT234) C1{ Fi Fi:0 FL}



static void Test_STT234()
{
  {
    init_simple_test("STT234");
    static STRUCT_IF_C STT234 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT234)");
    check_field_offset(lv, fa, 0, "STT234.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT234, STT234)
//============================================================================


struct  STT244  {
  int fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT244) C1{ Fi FL:0 FL}



static void Test_STT244()
{
  {
    init_simple_test("STT244");
    static STRUCT_IF_C STT244 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT244)");
    check_field_offset(lv, fa, 0, "STT244.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT244, STT244)
//============================================================================


struct  STT254  {
  int fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT254) C1{ Fi Fc:3 FL}



static void Test_STT254()
{
  {
    init_simple_test("STT254");
    static STRUCT_IF_C STT254 lv;
    check2(sizeof(lv), 16, "sizeof(STT254)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT254)");
    check_field_offset(lv, fa, 0, "STT254.fa");
    check_field_offset(lv, fb, 8, "STT254.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT254, STT254)
//============================================================================


struct  STT264  {
  int fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT264) C1{ Fi Fs:3 FL}



static void Test_STT264()
{
  {
    init_simple_test("STT264");
    static STRUCT_IF_C STT264 lv;
    check2(sizeof(lv), 16, "sizeof(STT264)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT264)");
    check_field_offset(lv, fa, 0, "STT264.fa");
    check_field_offset(lv, fb, 8, "STT264.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT264, STT264)
//============================================================================


struct  STT274  {
  int fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT274) C1{ Fi Fi:3 FL}



static void Test_STT274()
{
  {
    init_simple_test("STT274");
    static STRUCT_IF_C STT274 lv;
    check2(sizeof(lv), 16, "sizeof(STT274)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT274)");
    check_field_offset(lv, fa, 0, "STT274.fa");
    check_field_offset(lv, fb, 8, "STT274.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT274, STT274)
//============================================================================


struct  STT284  {
  int fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT284) C1{ Fi FL:3 FL}



static void Test_STT284()
{
  {
    init_simple_test("STT284");
    static STRUCT_IF_C STT284 lv;
    check2(sizeof(lv), 16, "sizeof(STT284)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT284)");
    check_field_offset(lv, fa, 0, "STT284.fa");
    check_field_offset(lv, fb, 8, "STT284.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT284, STT284)
//============================================================================


struct  STT294  {
  int fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT294) C1{ Fi Fs:8 FL}



static void Test_STT294()
{
  {
    init_simple_test("STT294");
    static STRUCT_IF_C STT294 lv;
    check2(sizeof(lv), 16, "sizeof(STT294)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT294)");
    check_field_offset(lv, fa, 0, "STT294.fa");
    check_field_offset(lv, fb, 8, "STT294.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT294, STT294)
//============================================================================


struct  STT2104  {
  int fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT2104) C1{ Fi Fi:8 FL}



static void Test_STT2104()
{
  {
    init_simple_test("STT2104");
    static STRUCT_IF_C STT2104 lv;
    check2(sizeof(lv), 16, "sizeof(STT2104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2104)");
    check_field_offset(lv, fa, 0, "STT2104.fa");
    check_field_offset(lv, fb, 8, "STT2104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2104, STT2104)
//============================================================================


struct  STT2114  {
  int fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT2114) C1{ Fi FL:8 FL}



static void Test_STT2114()
{
  {
    init_simple_test("STT2114");
    static STRUCT_IF_C STT2114 lv;
    check2(sizeof(lv), 16, "sizeof(STT2114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2114)");
    check_field_offset(lv, fa, 0, "STT2114.fa");
    check_field_offset(lv, fb, 8, "STT2114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2114, STT2114)
//============================================================================


struct  STT2124  {
  int fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT2124) C1{ Fi Fi:18 FL}



static void Test_STT2124()
{
  {
    init_simple_test("STT2124");
    static STRUCT_IF_C STT2124 lv;
    check2(sizeof(lv), 16, "sizeof(STT2124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2124)");
    check_field_offset(lv, fa, 0, "STT2124.fa");
    check_field_offset(lv, fb, 8, "STT2124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2124, STT2124)
//============================================================================


struct  STT2134  {
  int fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT2134) C1{ Fi FL:18 FL}



static void Test_STT2134()
{
  {
    init_simple_test("STT2134");
    static STRUCT_IF_C STT2134 lv;
    check2(sizeof(lv), 16, "sizeof(STT2134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2134)");
    check_field_offset(lv, fa, 0, "STT2134.fa");
    check_field_offset(lv, fb, 8, "STT2134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2134, STT2134)
//============================================================================


struct  STT2144  {
  int fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT2144) C1{ Fi FL:48 FL}



static void Test_STT2144()
{
  {
    init_simple_test("STT2144");
    static STRUCT_IF_C STT2144 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT2144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2144)");
    check_field_offset(lv, fa, 0, "STT2144.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2144, STT2144)
//============================================================================


struct  STT2154  {
  int fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT2154) C1{ Fi Fc:3 FL}



static void Test_STT2154()
{
  {
    init_simple_test("STT2154");
    static STRUCT_IF_C STT2154 lv;
    check2(sizeof(lv), 16, "sizeof(STT2154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2154)");
    check_field_offset(lv, fa, 0, "STT2154.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2154");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2154");
    check_field_offset(lv, fb, 8, "STT2154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2154, STT2154)
//============================================================================


struct  STT2164  {
  int fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT2164) C1{ Fi Fs:3 FL}



static void Test_STT2164()
{
  {
    init_simple_test("STT2164");
    static STRUCT_IF_C STT2164 lv;
    check2(sizeof(lv), 16, "sizeof(STT2164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2164)");
    check_field_offset(lv, fa, 0, "STT2164.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2164");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2164");
    check_field_offset(lv, fb, 8, "STT2164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2164, STT2164)
//============================================================================


struct  STT2174  {
  int fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT2174) C1{ Fi Fi:3 FL}



static void Test_STT2174()
{
  {
    init_simple_test("STT2174");
    static STRUCT_IF_C STT2174 lv;
    check2(sizeof(lv), 16, "sizeof(STT2174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2174)");
    check_field_offset(lv, fa, 0, "STT2174.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2174");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2174");
    check_field_offset(lv, fb, 8, "STT2174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2174, STT2174)
//============================================================================


struct  STT2184  {
  int fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT2184) C1{ Fi FL:3 FL}



static void Test_STT2184()
{
  {
    init_simple_test("STT2184");
    static STRUCT_IF_C STT2184 lv;
    check2(sizeof(lv), 16, "sizeof(STT2184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2184)");
    check_field_offset(lv, fa, 0, "STT2184.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2184");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2184");
    check_field_offset(lv, fb, 8, "STT2184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2184, STT2184)
//============================================================================


struct  STT2194  {
  int fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT2194) C1{ Fi Fs:8 FL}



static void Test_STT2194()
{
  {
    init_simple_test("STT2194");
    static STRUCT_IF_C STT2194 lv;
    check2(sizeof(lv), 16, "sizeof(STT2194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2194)");
    check_field_offset(lv, fa, 0, "STT2194.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2194");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2194");
    check_field_offset(lv, fb, 8, "STT2194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2194, STT2194)
//============================================================================


struct  STT2204  {
  int fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT2204) C1{ Fi Fi:8 FL}



static void Test_STT2204()
{
  {
    init_simple_test("STT2204");
    static STRUCT_IF_C STT2204 lv;
    check2(sizeof(lv), 16, "sizeof(STT2204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2204)");
    check_field_offset(lv, fa, 0, "STT2204.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2204");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2204");
    check_field_offset(lv, fb, 8, "STT2204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2204, STT2204)
//============================================================================


struct  STT2214  {
  int fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT2214) C1{ Fi FL:8 FL}



static void Test_STT2214()
{
  {
    init_simple_test("STT2214");
    static STRUCT_IF_C STT2214 lv;
    check2(sizeof(lv), 16, "sizeof(STT2214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2214)");
    check_field_offset(lv, fa, 0, "STT2214.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2214");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2214");
    check_field_offset(lv, fb, 8, "STT2214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2214, STT2214)
//============================================================================


struct  STT2224  {
  int fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT2224) C1{ Fi Fi:18 FL}



static void Test_STT2224()
{
  {
    init_simple_test("STT2224");
    static STRUCT_IF_C STT2224 lv;
    check2(sizeof(lv), 16, "sizeof(STT2224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2224)");
    check_field_offset(lv, fa, 0, "STT2224.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2224");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2224");
    check_field_offset(lv, fb, 8, "STT2224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2224, STT2224)
//============================================================================


struct  STT2234  {
  int fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT2234) C1{ Fi FL:18 FL}



static void Test_STT2234()
{
  {
    init_simple_test("STT2234");
    static STRUCT_IF_C STT2234 lv;
    check2(sizeof(lv), 16, "sizeof(STT2234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2234)");
    check_field_offset(lv, fa, 0, "STT2234.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2234");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2234");
    check_field_offset(lv, fb, 8, "STT2234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2234, STT2234)
//============================================================================


struct  STT2244  {
  int fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT2244) C1{ Fi FL:48 FL}



static void Test_STT2244()
{
  {
    init_simple_test("STT2244");
    static STRUCT_IF_C STT2244 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT2244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2244)");
    check_field_offset(lv, fa, 0, "STT2244.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2244");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2244");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2244, STT2244)
//============================================================================


struct  STT215  {
  int fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT215) C1{ Fi Fc:0 Fp}



static void Test_STT215()
{
  {
    init_simple_test("STT215");
    static STRUCT_IF_C STT215 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT215)");
    check_field_offset(lv, fa, 0, "STT215.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT215, STT215)
//============================================================================


struct  STT225  {
  int fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT225) C1{ Fi Fs:0 Fp}



static void Test_STT225()
{
  {
    init_simple_test("STT225");
    static STRUCT_IF_C STT225 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT225)");
    check_field_offset(lv, fa, 0, "STT225.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT225, STT225)
//============================================================================


struct  STT235  {
  int fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT235) C1{ Fi Fi:0 Fp}



static void Test_STT235()
{
  {
    init_simple_test("STT235");
    static STRUCT_IF_C STT235 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT235)");
    check_field_offset(lv, fa, 0, "STT235.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT235, STT235)
//============================================================================


struct  STT245  {
  int fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT245) C1{ Fi FL:0 Fp}



static void Test_STT245()
{
  {
    init_simple_test("STT245");
    static STRUCT_IF_C STT245 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT245)");
    check_field_offset(lv, fa, 0, "STT245.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT245, STT245)
//============================================================================


struct  STT255  {
  int fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT255) C1{ Fi Fc:3 Fp}



static void Test_STT255()
{
  {
    init_simple_test("STT255");
    static STRUCT_IF_C STT255 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT255)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT255)");
    check_field_offset(lv, fa, 0, "STT255.fa");
    check_field_offset(lv, fb, 8, "STT255.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT255, STT255)
//============================================================================


struct  STT265  {
  int fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT265) C1{ Fi Fs:3 Fp}



static void Test_STT265()
{
  {
    init_simple_test("STT265");
    static STRUCT_IF_C STT265 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT265)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT265)");
    check_field_offset(lv, fa, 0, "STT265.fa");
    check_field_offset(lv, fb, 8, "STT265.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT265, STT265)
//============================================================================


struct  STT275  {
  int fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT275) C1{ Fi Fi:3 Fp}



static void Test_STT275()
{
  {
    init_simple_test("STT275");
    static STRUCT_IF_C STT275 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT275)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT275)");
    check_field_offset(lv, fa, 0, "STT275.fa");
    check_field_offset(lv, fb, 8, "STT275.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT275, STT275)
//============================================================================


struct  STT285  {
  int fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT285) C1{ Fi FL:3 Fp}



static void Test_STT285()
{
  {
    init_simple_test("STT285");
    static STRUCT_IF_C STT285 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT285)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT285)");
    check_field_offset(lv, fa, 0, "STT285.fa");
    check_field_offset(lv, fb, 8, "STT285.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT285, STT285)
//============================================================================


struct  STT295  {
  int fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT295) C1{ Fi Fs:8 Fp}



static void Test_STT295()
{
  {
    init_simple_test("STT295");
    static STRUCT_IF_C STT295 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT295)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT295)");
    check_field_offset(lv, fa, 0, "STT295.fa");
    check_field_offset(lv, fb, 8, "STT295.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT295, STT295)
//============================================================================


struct  STT2105  {
  int fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT2105) C1{ Fi Fi:8 Fp}



static void Test_STT2105()
{
  {
    init_simple_test("STT2105");
    static STRUCT_IF_C STT2105 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2105)");
    check_field_offset(lv, fa, 0, "STT2105.fa");
    check_field_offset(lv, fb, 8, "STT2105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2105, STT2105)
//============================================================================


struct  STT2115  {
  int fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT2115) C1{ Fi FL:8 Fp}



static void Test_STT2115()
{
  {
    init_simple_test("STT2115");
    static STRUCT_IF_C STT2115 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2115)");
    check_field_offset(lv, fa, 0, "STT2115.fa");
    check_field_offset(lv, fb, 8, "STT2115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2115, STT2115)
//============================================================================


struct  STT2125  {
  int fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT2125) C1{ Fi Fi:18 Fp}



static void Test_STT2125()
{
  {
    init_simple_test("STT2125");
    static STRUCT_IF_C STT2125 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2125)");
    check_field_offset(lv, fa, 0, "STT2125.fa");
    check_field_offset(lv, fb, 8, "STT2125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2125, STT2125)
//============================================================================


struct  STT2135  {
  int fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT2135) C1{ Fi FL:18 Fp}



static void Test_STT2135()
{
  {
    init_simple_test("STT2135");
    static STRUCT_IF_C STT2135 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2135)");
    check_field_offset(lv, fa, 0, "STT2135.fa");
    check_field_offset(lv, fb, 8, "STT2135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2135, STT2135)
//============================================================================


struct  STT2145  {
  int fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT2145) C1{ Fi FL:48 Fp}



static void Test_STT2145()
{
  {
    init_simple_test("STT2145");
    static STRUCT_IF_C STT2145 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT2145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2145)");
    check_field_offset(lv, fa, 0, "STT2145.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2145, STT2145)
//============================================================================


struct  STT2155  {
  int fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT2155) C1{ Fi Fc:3 Fp}



static void Test_STT2155()
{
  {
    init_simple_test("STT2155");
    static STRUCT_IF_C STT2155 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2155)");
    check_field_offset(lv, fa, 0, "STT2155.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2155");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2155");
    check_field_offset(lv, fb, 8, "STT2155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2155, STT2155)
//============================================================================


struct  STT2165  {
  int fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT2165) C1{ Fi Fs:3 Fp}



static void Test_STT2165()
{
  {
    init_simple_test("STT2165");
    static STRUCT_IF_C STT2165 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2165)");
    check_field_offset(lv, fa, 0, "STT2165.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2165");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2165");
    check_field_offset(lv, fb, 8, "STT2165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2165, STT2165)
//============================================================================


struct  STT2175  {
  int fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT2175) C1{ Fi Fi:3 Fp}



static void Test_STT2175()
{
  {
    init_simple_test("STT2175");
    static STRUCT_IF_C STT2175 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2175)");
    check_field_offset(lv, fa, 0, "STT2175.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2175");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2175");
    check_field_offset(lv, fb, 8, "STT2175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2175, STT2175)
//============================================================================


struct  STT2185  {
  int fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT2185) C1{ Fi FL:3 Fp}



static void Test_STT2185()
{
  {
    init_simple_test("STT2185");
    static STRUCT_IF_C STT2185 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2185)");
    check_field_offset(lv, fa, 0, "STT2185.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2185");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2185");
    check_field_offset(lv, fb, 8, "STT2185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2185, STT2185)
//============================================================================


struct  STT2195  {
  int fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT2195) C1{ Fi Fs:8 Fp}



static void Test_STT2195()
{
  {
    init_simple_test("STT2195");
    static STRUCT_IF_C STT2195 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2195)");
    check_field_offset(lv, fa, 0, "STT2195.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2195");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2195");
    check_field_offset(lv, fb, 8, "STT2195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2195, STT2195)
//============================================================================


struct  STT2205  {
  int fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT2205) C1{ Fi Fi:8 Fp}



static void Test_STT2205()
{
  {
    init_simple_test("STT2205");
    static STRUCT_IF_C STT2205 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2205)");
    check_field_offset(lv, fa, 0, "STT2205.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2205");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2205");
    check_field_offset(lv, fb, 8, "STT2205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2205, STT2205)
//============================================================================


struct  STT2215  {
  int fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT2215) C1{ Fi FL:8 Fp}



static void Test_STT2215()
{
  {
    init_simple_test("STT2215");
    static STRUCT_IF_C STT2215 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2215)");
    check_field_offset(lv, fa, 0, "STT2215.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2215");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2215");
    check_field_offset(lv, fb, 8, "STT2215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2215, STT2215)
//============================================================================


struct  STT2225  {
  int fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT2225) C1{ Fi Fi:18 Fp}



static void Test_STT2225()
{
  {
    init_simple_test("STT2225");
    static STRUCT_IF_C STT2225 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2225)");
    check_field_offset(lv, fa, 0, "STT2225.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2225");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2225");
    check_field_offset(lv, fb, 8, "STT2225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2225, STT2225)
//============================================================================


struct  STT2235  {
  int fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT2235) C1{ Fi FL:18 Fp}



static void Test_STT2235()
{
  {
    init_simple_test("STT2235");
    static STRUCT_IF_C STT2235 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2235)");
    check_field_offset(lv, fa, 0, "STT2235.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2235");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2235");
    check_field_offset(lv, fb, 8, "STT2235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2235, STT2235)
//============================================================================


struct  STT2245  {
  int fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT2245) C1{ Fi FL:48 Fp}



static void Test_STT2245()
{
  {
    init_simple_test("STT2245");
    static STRUCT_IF_C STT2245 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT2245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2245)");
    check_field_offset(lv, fa, 0, "STT2245.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2245");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2245");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2245, STT2245)
//============================================================================


struct  STT216  {
  int fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT216) C1{ Fi Fc:0 Fi}



static void Test_STT216()
{
  {
    init_simple_test("STT216");
    static STRUCT_IF_C STT216 lv;
    check2(sizeof(lv), 8, "sizeof(STT216)");
    check2(__alignof__(lv), 4, "__alignof__(STT216)");
    check_field_offset(lv, fa, 0, "STT216.fa");
    check_field_offset(lv, fb, 4, "STT216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT216, STT216)
//============================================================================


struct  STT226  {
  int fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT226) C1{ Fi Fs:0 Fi}



static void Test_STT226()
{
  {
    init_simple_test("STT226");
    static STRUCT_IF_C STT226 lv;
    check2(sizeof(lv), 8, "sizeof(STT226)");
    check2(__alignof__(lv), 4, "__alignof__(STT226)");
    check_field_offset(lv, fa, 0, "STT226.fa");
    check_field_offset(lv, fb, 4, "STT226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT226, STT226)
//============================================================================


struct  STT236  {
  int fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT236) C1{ Fi Fi:0 Fi}



static void Test_STT236()
{
  {
    init_simple_test("STT236");
    static STRUCT_IF_C STT236 lv;
    check2(sizeof(lv), 8, "sizeof(STT236)");
    check2(__alignof__(lv), 4, "__alignof__(STT236)");
    check_field_offset(lv, fa, 0, "STT236.fa");
    check_field_offset(lv, fb, 4, "STT236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT236, STT236)
//============================================================================


struct  STT246  {
  int fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT246) C1{ Fi FL:0 Fi}



static void Test_STT246()
{
  {
    init_simple_test("STT246");
    static STRUCT_IF_C STT246 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT246)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT246)");
    check_field_offset(lv, fa, 0, "STT246.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT246, STT246)
//============================================================================


struct  STT256  {
  int fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT256) C1{ Fi Fc:3 Fi}



static void Test_STT256()
{
  {
    init_simple_test("STT256");
    static STRUCT_IF_C STT256 lv;
    check2(sizeof(lv), 12, "sizeof(STT256)");
    check2(__alignof__(lv), 4, "__alignof__(STT256)");
    check_field_offset(lv, fa, 0, "STT256.fa");
    check_field_offset(lv, fb, 8, "STT256.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT256, STT256)
//============================================================================


struct  STT266  {
  int fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT266) C1{ Fi Fs:3 Fi}



static void Test_STT266()
{
  {
    init_simple_test("STT266");
    static STRUCT_IF_C STT266 lv;
    check2(sizeof(lv), 12, "sizeof(STT266)");
    check2(__alignof__(lv), 4, "__alignof__(STT266)");
    check_field_offset(lv, fa, 0, "STT266.fa");
    check_field_offset(lv, fb, 8, "STT266.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT266, STT266)
//============================================================================


struct  STT276  {
  int fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT276) C1{ Fi Fi:3 Fi}



static void Test_STT276()
{
  {
    init_simple_test("STT276");
    static STRUCT_IF_C STT276 lv;
    check2(sizeof(lv), 12, "sizeof(STT276)");
    check2(__alignof__(lv), 4, "__alignof__(STT276)");
    check_field_offset(lv, fa, 0, "STT276.fa");
    check_field_offset(lv, fb, 8, "STT276.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT276, STT276)
//============================================================================


struct  STT286  {
  int fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT286) C1{ Fi FL:3 Fi}



static void Test_STT286()
{
  {
    init_simple_test("STT286");
    static STRUCT_IF_C STT286 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT286)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT286)");
    check_field_offset(lv, fa, 0, "STT286.fa");
    check_field_offset(lv, fb, 8, "STT286.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT286, STT286)
//============================================================================


struct  STT296  {
  int fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT296) C1{ Fi Fs:8 Fi}



static void Test_STT296()
{
  {
    init_simple_test("STT296");
    static STRUCT_IF_C STT296 lv;
    check2(sizeof(lv), 12, "sizeof(STT296)");
    check2(__alignof__(lv), 4, "__alignof__(STT296)");
    check_field_offset(lv, fa, 0, "STT296.fa");
    check_field_offset(lv, fb, 8, "STT296.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT296, STT296)
//============================================================================


struct  STT2106  {
  int fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT2106) C1{ Fi Fi:8 Fi}



static void Test_STT2106()
{
  {
    init_simple_test("STT2106");
    static STRUCT_IF_C STT2106 lv;
    check2(sizeof(lv), 12, "sizeof(STT2106)");
    check2(__alignof__(lv), 4, "__alignof__(STT2106)");
    check_field_offset(lv, fa, 0, "STT2106.fa");
    check_field_offset(lv, fb, 8, "STT2106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2106, STT2106)
//============================================================================


struct  STT2116  {
  int fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT2116) C1{ Fi FL:8 Fi}



static void Test_STT2116()
{
  {
    init_simple_test("STT2116");
    static STRUCT_IF_C STT2116 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT2116)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2116)");
    check_field_offset(lv, fa, 0, "STT2116.fa");
    check_field_offset(lv, fb, 8, "STT2116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2116, STT2116)
//============================================================================


struct  STT2126  {
  int fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT2126) C1{ Fi Fi:18 Fi}



static void Test_STT2126()
{
  {
    init_simple_test("STT2126");
    static STRUCT_IF_C STT2126 lv;
    check2(sizeof(lv), 12, "sizeof(STT2126)");
    check2(__alignof__(lv), 4, "__alignof__(STT2126)");
    check_field_offset(lv, fa, 0, "STT2126.fa");
    check_field_offset(lv, fb, 8, "STT2126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2126, STT2126)
//============================================================================


struct  STT2136  {
  int fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT2136) C1{ Fi FL:18 Fi}



static void Test_STT2136()
{
  {
    init_simple_test("STT2136");
    static STRUCT_IF_C STT2136 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT2136)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2136)");
    check_field_offset(lv, fa, 0, "STT2136.fa");
    check_field_offset(lv, fb, 8, "STT2136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2136, STT2136)
//============================================================================


struct  STT2146  {
  int fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT2146) C1{ Fi FL:48 Fi}



static void Test_STT2146()
{
  {
    init_simple_test("STT2146");
    static STRUCT_IF_C STT2146 lv;
    check2(sizeof(lv), ABISELECT(20,16), "sizeof(STT2146)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2146)");
    check_field_offset(lv, fa, 0, "STT2146.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2146, STT2146)
//============================================================================


struct  STT2156  {
  int fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT2156) C1{ Fi Fc:3 Fi}



static void Test_STT2156()
{
  {
    init_simple_test("STT2156");
    static STRUCT_IF_C STT2156 lv;
    check2(sizeof(lv), 12, "sizeof(STT2156)");
    check2(__alignof__(lv), 4, "__alignof__(STT2156)");
    check_field_offset(lv, fa, 0, "STT2156.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2156");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2156");
    check_field_offset(lv, fb, 8, "STT2156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2156, STT2156)
//============================================================================


struct  STT2166  {
  int fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT2166) C1{ Fi Fs:3 Fi}



static void Test_STT2166()
{
  {
    init_simple_test("STT2166");
    static STRUCT_IF_C STT2166 lv;
    check2(sizeof(lv), 12, "sizeof(STT2166)");
    check2(__alignof__(lv), 4, "__alignof__(STT2166)");
    check_field_offset(lv, fa, 0, "STT2166.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2166");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2166");
    check_field_offset(lv, fb, 8, "STT2166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2166, STT2166)
//============================================================================


struct  STT2176  {
  int fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT2176) C1{ Fi Fi:3 Fi}



static void Test_STT2176()
{
  {
    init_simple_test("STT2176");
    static STRUCT_IF_C STT2176 lv;
    check2(sizeof(lv), 12, "sizeof(STT2176)");
    check2(__alignof__(lv), 4, "__alignof__(STT2176)");
    check_field_offset(lv, fa, 0, "STT2176.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2176");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2176");
    check_field_offset(lv, fb, 8, "STT2176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2176, STT2176)
//============================================================================


struct  STT2186  {
  int fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT2186) C1{ Fi FL:3 Fi}



static void Test_STT2186()
{
  {
    init_simple_test("STT2186");
    static STRUCT_IF_C STT2186 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2186)");
    check_field_offset(lv, fa, 0, "STT2186.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2186");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2186");
    check_field_offset(lv, fb, 8, "STT2186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2186, STT2186)
//============================================================================


struct  STT2196  {
  int fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT2196) C1{ Fi Fs:8 Fi}



static void Test_STT2196()
{
  {
    init_simple_test("STT2196");
    static STRUCT_IF_C STT2196 lv;
    check2(sizeof(lv), 12, "sizeof(STT2196)");
    check2(__alignof__(lv), 4, "__alignof__(STT2196)");
    check_field_offset(lv, fa, 0, "STT2196.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2196");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2196");
    check_field_offset(lv, fb, 8, "STT2196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2196, STT2196)
//============================================================================


struct  STT2206  {
  int fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT2206) C1{ Fi Fi:8 Fi}



static void Test_STT2206()
{
  {
    init_simple_test("STT2206");
    static STRUCT_IF_C STT2206 lv;
    check2(sizeof(lv), 12, "sizeof(STT2206)");
    check2(__alignof__(lv), 4, "__alignof__(STT2206)");
    check_field_offset(lv, fa, 0, "STT2206.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2206");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2206");
    check_field_offset(lv, fb, 8, "STT2206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2206, STT2206)
//============================================================================


struct  STT2216  {
  int fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT2216) C1{ Fi FL:8 Fi}



static void Test_STT2216()
{
  {
    init_simple_test("STT2216");
    static STRUCT_IF_C STT2216 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2216)");
    check_field_offset(lv, fa, 0, "STT2216.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2216");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2216");
    check_field_offset(lv, fb, 8, "STT2216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2216, STT2216)
//============================================================================


struct  STT2226  {
  int fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT2226) C1{ Fi Fi:18 Fi}



static void Test_STT2226()
{
  {
    init_simple_test("STT2226");
    static STRUCT_IF_C STT2226 lv;
    check2(sizeof(lv), 12, "sizeof(STT2226)");
    check2(__alignof__(lv), 4, "__alignof__(STT2226)");
    check_field_offset(lv, fa, 0, "STT2226.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2226");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2226");
    check_field_offset(lv, fb, 8, "STT2226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2226, STT2226)
//============================================================================


struct  STT2236  {
  int fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT2236) C1{ Fi FL:18 Fi}



static void Test_STT2236()
{
  {
    init_simple_test("STT2236");
    static STRUCT_IF_C STT2236 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2236)");
    check_field_offset(lv, fa, 0, "STT2236.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2236");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2236");
    check_field_offset(lv, fb, 8, "STT2236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2236, STT2236)
//============================================================================


struct  STT2246  {
  int fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT2246) C1{ Fi FL:48 Fi}



static void Test_STT2246()
{
  {
    init_simple_test("STT2246");
    static STRUCT_IF_C STT2246 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT2246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2246)");
    check_field_offset(lv, fa, 0, "STT2246.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2246");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2246");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2246, STT2246)
//============================================================================


struct  STT217  {
  int fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT217) C1{ Fi Fc:0 FL}



static void Test_STT217()
{
  {
    init_simple_test("STT217");
    static STRUCT_IF_C STT217 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT217)");
    check_field_offset(lv, fa, 0, "STT217.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT217, STT217)
//============================================================================


struct  STT227  {
  int fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT227) C1{ Fi Fs:0 FL}



static void Test_STT227()
{
  {
    init_simple_test("STT227");
    static STRUCT_IF_C STT227 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT227)");
    check_field_offset(lv, fa, 0, "STT227.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT227, STT227)
//============================================================================


struct  STT237  {
  int fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT237) C1{ Fi Fi:0 FL}



static void Test_STT237()
{
  {
    init_simple_test("STT237");
    static STRUCT_IF_C STT237 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT237)");
    check_field_offset(lv, fa, 0, "STT237.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT237, STT237)
//============================================================================


struct  STT247  {
  int fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT247) C1{ Fi FL:0 FL}



static void Test_STT247()
{
  {
    init_simple_test("STT247");
    static STRUCT_IF_C STT247 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT247)");
    check_field_offset(lv, fa, 0, "STT247.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT247, STT247)
//============================================================================


struct  STT257  {
  int fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT257) C1{ Fi Fc:3 FL}



static void Test_STT257()
{
  {
    init_simple_test("STT257");
    static STRUCT_IF_C STT257 lv;
    check2(sizeof(lv), 16, "sizeof(STT257)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT257)");
    check_field_offset(lv, fa, 0, "STT257.fa");
    check_field_offset(lv, fb, 8, "STT257.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT257, STT257)
//============================================================================


struct  STT267  {
  int fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT267) C1{ Fi Fs:3 FL}



static void Test_STT267()
{
  {
    init_simple_test("STT267");
    static STRUCT_IF_C STT267 lv;
    check2(sizeof(lv), 16, "sizeof(STT267)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT267)");
    check_field_offset(lv, fa, 0, "STT267.fa");
    check_field_offset(lv, fb, 8, "STT267.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT267, STT267)
//============================================================================


struct  STT277  {
  int fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT277) C1{ Fi Fi:3 FL}



static void Test_STT277()
{
  {
    init_simple_test("STT277");
    static STRUCT_IF_C STT277 lv;
    check2(sizeof(lv), 16, "sizeof(STT277)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT277)");
    check_field_offset(lv, fa, 0, "STT277.fa");
    check_field_offset(lv, fb, 8, "STT277.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT277, STT277)
//============================================================================


struct  STT287  {
  int fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT287) C1{ Fi FL:3 FL}



static void Test_STT287()
{
  {
    init_simple_test("STT287");
    static STRUCT_IF_C STT287 lv;
    check2(sizeof(lv), 16, "sizeof(STT287)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT287)");
    check_field_offset(lv, fa, 0, "STT287.fa");
    check_field_offset(lv, fb, 8, "STT287.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT287, STT287)
//============================================================================


struct  STT297  {
  int fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT297) C1{ Fi Fs:8 FL}



static void Test_STT297()
{
  {
    init_simple_test("STT297");
    static STRUCT_IF_C STT297 lv;
    check2(sizeof(lv), 16, "sizeof(STT297)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT297)");
    check_field_offset(lv, fa, 0, "STT297.fa");
    check_field_offset(lv, fb, 8, "STT297.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT297, STT297)
//============================================================================


struct  STT2107  {
  int fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT2107) C1{ Fi Fi:8 FL}



static void Test_STT2107()
{
  {
    init_simple_test("STT2107");
    static STRUCT_IF_C STT2107 lv;
    check2(sizeof(lv), 16, "sizeof(STT2107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2107)");
    check_field_offset(lv, fa, 0, "STT2107.fa");
    check_field_offset(lv, fb, 8, "STT2107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2107, STT2107)
//============================================================================


struct  STT2117  {
  int fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT2117) C1{ Fi FL:8 FL}



static void Test_STT2117()
{
  {
    init_simple_test("STT2117");
    static STRUCT_IF_C STT2117 lv;
    check2(sizeof(lv), 16, "sizeof(STT2117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2117)");
    check_field_offset(lv, fa, 0, "STT2117.fa");
    check_field_offset(lv, fb, 8, "STT2117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2117, STT2117)
//============================================================================


struct  STT2127  {
  int fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT2127) C1{ Fi Fi:18 FL}



static void Test_STT2127()
{
  {
    init_simple_test("STT2127");
    static STRUCT_IF_C STT2127 lv;
    check2(sizeof(lv), 16, "sizeof(STT2127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2127)");
    check_field_offset(lv, fa, 0, "STT2127.fa");
    check_field_offset(lv, fb, 8, "STT2127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2127, STT2127)
//============================================================================


struct  STT2137  {
  int fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT2137) C1{ Fi FL:18 FL}



static void Test_STT2137()
{
  {
    init_simple_test("STT2137");
    static STRUCT_IF_C STT2137 lv;
    check2(sizeof(lv), 16, "sizeof(STT2137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2137)");
    check_field_offset(lv, fa, 0, "STT2137.fa");
    check_field_offset(lv, fb, 8, "STT2137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2137, STT2137)
//============================================================================


struct  STT2147  {
  int fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT2147) C1{ Fi FL:48 FL}



static void Test_STT2147()
{
  {
    init_simple_test("STT2147");
    static STRUCT_IF_C STT2147 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT2147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2147)");
    check_field_offset(lv, fa, 0, "STT2147.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2147, STT2147)
//============================================================================


struct  STT2157  {
  int fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT2157) C1{ Fi Fc:3 FL}



static void Test_STT2157()
{
  {
    init_simple_test("STT2157");
    static STRUCT_IF_C STT2157 lv;
    check2(sizeof(lv), 16, "sizeof(STT2157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2157)");
    check_field_offset(lv, fa, 0, "STT2157.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2157");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2157");
    check_field_offset(lv, fb, 8, "STT2157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2157, STT2157)
//============================================================================


struct  STT2167  {
  int fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT2167) C1{ Fi Fs:3 FL}



static void Test_STT2167()
{
  {
    init_simple_test("STT2167");
    static STRUCT_IF_C STT2167 lv;
    check2(sizeof(lv), 16, "sizeof(STT2167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2167)");
    check_field_offset(lv, fa, 0, "STT2167.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2167");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2167");
    check_field_offset(lv, fb, 8, "STT2167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2167, STT2167)
//============================================================================


struct  STT2177  {
  int fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT2177) C1{ Fi Fi:3 FL}



static void Test_STT2177()
{
  {
    init_simple_test("STT2177");
    static STRUCT_IF_C STT2177 lv;
    check2(sizeof(lv), 16, "sizeof(STT2177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2177)");
    check_field_offset(lv, fa, 0, "STT2177.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2177");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2177");
    check_field_offset(lv, fb, 8, "STT2177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2177, STT2177)
//============================================================================


struct  STT2187  {
  int fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT2187) C1{ Fi FL:3 FL}



static void Test_STT2187()
{
  {
    init_simple_test("STT2187");
    static STRUCT_IF_C STT2187 lv;
    check2(sizeof(lv), 16, "sizeof(STT2187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2187)");
    check_field_offset(lv, fa, 0, "STT2187.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2187");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2187");
    check_field_offset(lv, fb, 8, "STT2187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2187, STT2187)
//============================================================================


struct  STT2197  {
  int fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT2197) C1{ Fi Fs:8 FL}



static void Test_STT2197()
{
  {
    init_simple_test("STT2197");
    static STRUCT_IF_C STT2197 lv;
    check2(sizeof(lv), 16, "sizeof(STT2197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2197)");
    check_field_offset(lv, fa, 0, "STT2197.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2197");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2197");
    check_field_offset(lv, fb, 8, "STT2197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2197, STT2197)
//============================================================================


struct  STT2207  {
  int fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT2207) C1{ Fi Fi:8 FL}



static void Test_STT2207()
{
  {
    init_simple_test("STT2207");
    static STRUCT_IF_C STT2207 lv;
    check2(sizeof(lv), 16, "sizeof(STT2207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2207)");
    check_field_offset(lv, fa, 0, "STT2207.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2207");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2207");
    check_field_offset(lv, fb, 8, "STT2207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2207, STT2207)
//============================================================================


struct  STT2217  {
  int fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT2217) C1{ Fi FL:8 FL}



static void Test_STT2217()
{
  {
    init_simple_test("STT2217");
    static STRUCT_IF_C STT2217 lv;
    check2(sizeof(lv), 16, "sizeof(STT2217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2217)");
    check_field_offset(lv, fa, 0, "STT2217.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2217");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2217");
    check_field_offset(lv, fb, 8, "STT2217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2217, STT2217)
//============================================================================


struct  STT2227  {
  int fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT2227) C1{ Fi Fi:18 FL}



static void Test_STT2227()
{
  {
    init_simple_test("STT2227");
    static STRUCT_IF_C STT2227 lv;
    check2(sizeof(lv), 16, "sizeof(STT2227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2227)");
    check_field_offset(lv, fa, 0, "STT2227.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2227");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2227");
    check_field_offset(lv, fb, 8, "STT2227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2227, STT2227)
//============================================================================


struct  STT2237  {
  int fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT2237) C1{ Fi FL:18 FL}



static void Test_STT2237()
{
  {
    init_simple_test("STT2237");
    static STRUCT_IF_C STT2237 lv;
    check2(sizeof(lv), 16, "sizeof(STT2237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2237)");
    check_field_offset(lv, fa, 0, "STT2237.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2237");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2237");
    check_field_offset(lv, fb, 8, "STT2237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2237, STT2237)
//============================================================================


struct  STT2247  {
  int fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT2247) C1{ Fi FL:48 FL}



static void Test_STT2247()
{
  {
    init_simple_test("STT2247");
    static STRUCT_IF_C STT2247 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT2247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2247)");
    check_field_offset(lv, fa, 0, "STT2247.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2247");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2247");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2247, STT2247)
//============================================================================


struct  STT218  {
  int fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT218) C1{ Fi Fc:0 FD}



static void Test_STT218()
{
  {
    init_simple_test("STT218");
    static STRUCT_IF_C STT218 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT218)");
    check_field_offset(lv, fa, 0, "STT218.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT218, STT218)
//============================================================================


struct  STT228  {
  int fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT228) C1{ Fi Fs:0 FD}



static void Test_STT228()
{
  {
    init_simple_test("STT228");
    static STRUCT_IF_C STT228 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT228)");
    check_field_offset(lv, fa, 0, "STT228.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT228, STT228)
//============================================================================


struct  STT238  {
  int fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT238) C1{ Fi Fi:0 FD}



static void Test_STT238()
{
  {
    init_simple_test("STT238");
    static STRUCT_IF_C STT238 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT238)");
    check_field_offset(lv, fa, 0, "STT238.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT238, STT238)
//============================================================================


struct  STT248  {
  int fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT248) C1{ Fi FL:0 FD}



static void Test_STT248()
{
  {
    init_simple_test("STT248");
    static STRUCT_IF_C STT248 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT248)");
    check_field_offset(lv, fa, 0, "STT248.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT248, STT248)
//============================================================================


struct  STT258  {
  int fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT258) C1{ Fi Fc:3 FD}



static void Test_STT258()
{
  {
    init_simple_test("STT258");
    static STRUCT_IF_C STT258 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT258)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT258)");
    check_field_offset(lv, fa, 0, "STT258.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT258.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT258, STT258)
//============================================================================


struct  STT268  {
  int fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT268) C1{ Fi Fs:3 FD}



static void Test_STT268()
{
  {
    init_simple_test("STT268");
    static STRUCT_IF_C STT268 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT268)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT268)");
    check_field_offset(lv, fa, 0, "STT268.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT268.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT268, STT268)
//============================================================================


struct  STT278  {
  int fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT278) C1{ Fi Fi:3 FD}



static void Test_STT278()
{
  {
    init_simple_test("STT278");
    static STRUCT_IF_C STT278 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT278)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT278)");
    check_field_offset(lv, fa, 0, "STT278.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT278.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT278, STT278)
//============================================================================


struct  STT288  {
  int fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT288) C1{ Fi FL:3 FD}



static void Test_STT288()
{
  {
    init_simple_test("STT288");
    static STRUCT_IF_C STT288 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT288)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT288)");
    check_field_offset(lv, fa, 0, "STT288.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT288.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT288, STT288)
//============================================================================


struct  STT298  {
  int fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT298) C1{ Fi Fs:8 FD}



static void Test_STT298()
{
  {
    init_simple_test("STT298");
    static STRUCT_IF_C STT298 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT298)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT298)");
    check_field_offset(lv, fa, 0, "STT298.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT298.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT298, STT298)
//============================================================================


struct  STT2108  {
  int fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT2108) C1{ Fi Fi:8 FD}



static void Test_STT2108()
{
  {
    init_simple_test("STT2108");
    static STRUCT_IF_C STT2108 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2108)");
    check_field_offset(lv, fa, 0, "STT2108.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2108, STT2108)
//============================================================================


struct  STT2118  {
  int fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT2118) C1{ Fi FL:8 FD}



static void Test_STT2118()
{
  {
    init_simple_test("STT2118");
    static STRUCT_IF_C STT2118 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2118)");
    check_field_offset(lv, fa, 0, "STT2118.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2118, STT2118)
//============================================================================


struct  STT2128  {
  int fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT2128) C1{ Fi Fi:18 FD}



static void Test_STT2128()
{
  {
    init_simple_test("STT2128");
    static STRUCT_IF_C STT2128 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2128)");
    check_field_offset(lv, fa, 0, "STT2128.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2128, STT2128)
//============================================================================


struct  STT2138  {
  int fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT2138) C1{ Fi FL:18 FD}



static void Test_STT2138()
{
  {
    init_simple_test("STT2138");
    static STRUCT_IF_C STT2138 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2138)");
    check_field_offset(lv, fa, 0, "STT2138.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2138, STT2138)
//============================================================================


struct  STT2148  {
  int fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT2148) C1{ Fi FL:48 FD}



static void Test_STT2148()
{
  {
    init_simple_test("STT2148");
    static STRUCT_IF_C STT2148 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT2148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2148)");
    check_field_offset(lv, fa, 0, "STT2148.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2148, STT2148)
//============================================================================


struct  STT2158  {
  int fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT2158) C1{ Fi Fc:3 FD}



static void Test_STT2158()
{
  {
    init_simple_test("STT2158");
    static STRUCT_IF_C STT2158 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2158)");
    check_field_offset(lv, fa, 0, "STT2158.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2158");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2158");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2158, STT2158)
//============================================================================


struct  STT2168  {
  int fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT2168) C1{ Fi Fs:3 FD}



static void Test_STT2168()
{
  {
    init_simple_test("STT2168");
    static STRUCT_IF_C STT2168 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2168)");
    check_field_offset(lv, fa, 0, "STT2168.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2168");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2168");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2168, STT2168)
//============================================================================


struct  STT2178  {
  int fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT2178) C1{ Fi Fi:3 FD}



static void Test_STT2178()
{
  {
    init_simple_test("STT2178");
    static STRUCT_IF_C STT2178 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2178)");
    check_field_offset(lv, fa, 0, "STT2178.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2178");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2178");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2178, STT2178)
//============================================================================


struct  STT2188  {
  int fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT2188) C1{ Fi FL:3 FD}



static void Test_STT2188()
{
  {
    init_simple_test("STT2188");
    static STRUCT_IF_C STT2188 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2188)");
    check_field_offset(lv, fa, 0, "STT2188.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2188");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2188");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2188, STT2188)
//============================================================================


struct  STT2198  {
  int fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT2198) C1{ Fi Fs:8 FD}



static void Test_STT2198()
{
  {
    init_simple_test("STT2198");
    static STRUCT_IF_C STT2198 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2198)");
    check_field_offset(lv, fa, 0, "STT2198.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2198");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2198");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2198, STT2198)
//============================================================================


struct  STT2208  {
  int fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT2208) C1{ Fi Fi:8 FD}



static void Test_STT2208()
{
  {
    init_simple_test("STT2208");
    static STRUCT_IF_C STT2208 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2208)");
    check_field_offset(lv, fa, 0, "STT2208.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2208");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2208");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2208, STT2208)
//============================================================================


struct  STT2218  {
  int fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT2218) C1{ Fi FL:8 FD}



static void Test_STT2218()
{
  {
    init_simple_test("STT2218");
    static STRUCT_IF_C STT2218 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2218)");
    check_field_offset(lv, fa, 0, "STT2218.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2218");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2218");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2218, STT2218)
//============================================================================


struct  STT2228  {
  int fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT2228) C1{ Fi Fi:18 FD}



static void Test_STT2228()
{
  {
    init_simple_test("STT2228");
    static STRUCT_IF_C STT2228 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2228)");
    check_field_offset(lv, fa, 0, "STT2228.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2228");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2228");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2228, STT2228)
//============================================================================


struct  STT2238  {
  int fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT2238) C1{ Fi FL:18 FD}



static void Test_STT2238()
{
  {
    init_simple_test("STT2238");
    static STRUCT_IF_C STT2238 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT2238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2238)");
    check_field_offset(lv, fa, 0, "STT2238.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2238");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2238");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT2238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2238, STT2238)
//============================================================================


struct  STT2248  {
  int fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT2248) C1{ Fi FL:48 FD}



static void Test_STT2248()
{
  {
    init_simple_test("STT2248");
    static STRUCT_IF_C STT2248 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT2248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT2248)");
    check_field_offset(lv, fa, 0, "STT2248.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2248");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2248");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT2248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2248, STT2248)
//============================================================================


struct  STT219  {
  int fa;
  unsigned char  :0;
};
//SIG(1 STT219) C1{ Fi Fc:0}



static void Test_STT219()
{
  {
    init_simple_test("STT219");
    static STRUCT_IF_C STT219 lv;
    check2(sizeof(lv), 4, "sizeof(STT219)");
    check2(__alignof__(lv), 4, "__alignof__(STT219)");
    check_field_offset(lv, fa, 0, "STT219.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT219, STT219)
//============================================================================


struct  STT229  {
  int fa;
  unsigned short  :0;
};
//SIG(1 STT229) C1{ Fi Fs:0}



static void Test_STT229()
{
  {
    init_simple_test("STT229");
    static STRUCT_IF_C STT229 lv;
    check2(sizeof(lv), 4, "sizeof(STT229)");
    check2(__alignof__(lv), 4, "__alignof__(STT229)");
    check_field_offset(lv, fa, 0, "STT229.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT229, STT229)
//============================================================================


struct  STT239  {
  int fa;
  unsigned int  :0;
};
//SIG(1 STT239) C1{ Fi Fi:0}



static void Test_STT239()
{
  {
    init_simple_test("STT239");
    static STRUCT_IF_C STT239 lv;
    check2(sizeof(lv), 4, "sizeof(STT239)");
    check2(__alignof__(lv), 4, "__alignof__(STT239)");
    check_field_offset(lv, fa, 0, "STT239.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT239, STT239)
//============================================================================


struct  STT249  {
  int fa;
  __tsu64  :0;
};
//SIG(1 STT249) C1{ Fi FL:0}



static void Test_STT249()
{
  {
    init_simple_test("STT249");
    static STRUCT_IF_C STT249 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT249)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT249)");
    check_field_offset(lv, fa, 0, "STT249.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT249, STT249)
//============================================================================


struct  STT259  {
  int fa;
  unsigned char  :3;
};
//SIG(1 STT259) C1{ Fi Fc:3}



static void Test_STT259()
{
  {
    init_simple_test("STT259");
    static STRUCT_IF_C STT259 lv;
    check2(sizeof(lv), 8, "sizeof(STT259)");
    check2(__alignof__(lv), 4, "__alignof__(STT259)");
    check_field_offset(lv, fa, 0, "STT259.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT259, STT259)
//============================================================================


struct  STT269  {
  int fa;
  unsigned short  :3;
};
//SIG(1 STT269) C1{ Fi Fs:3}



static void Test_STT269()
{
  {
    init_simple_test("STT269");
    static STRUCT_IF_C STT269 lv;
    check2(sizeof(lv), 8, "sizeof(STT269)");
    check2(__alignof__(lv), 4, "__alignof__(STT269)");
    check_field_offset(lv, fa, 0, "STT269.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT269, STT269)
//============================================================================


struct  STT279  {
  int fa;
  unsigned int  :3;
};
//SIG(1 STT279) C1{ Fi Fi:3}



static void Test_STT279()
{
  {
    init_simple_test("STT279");
    static STRUCT_IF_C STT279 lv;
    check2(sizeof(lv), 8, "sizeof(STT279)");
    check2(__alignof__(lv), 4, "__alignof__(STT279)");
    check_field_offset(lv, fa, 0, "STT279.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT279, STT279)
//============================================================================


struct  STT289  {
  int fa;
  __tsu64  :3;
};
//SIG(1 STT289) C1{ Fi FL:3}



static void Test_STT289()
{
  {
    init_simple_test("STT289");
    static STRUCT_IF_C STT289 lv;
    check2(sizeof(lv), 8, "sizeof(STT289)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT289)");
    check_field_offset(lv, fa, 0, "STT289.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT289, STT289)
//============================================================================


struct  STT299  {
  int fa;
  unsigned short  :8;
};
//SIG(1 STT299) C1{ Fi Fs:8}



static void Test_STT299()
{
  {
    init_simple_test("STT299");
    static STRUCT_IF_C STT299 lv;
    check2(sizeof(lv), 8, "sizeof(STT299)");
    check2(__alignof__(lv), 4, "__alignof__(STT299)");
    check_field_offset(lv, fa, 0, "STT299.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT299, STT299)
//============================================================================


struct  STT2109  {
  int fa;
  unsigned int  :8;
};
//SIG(1 STT2109) C1{ Fi Fi:8}



static void Test_STT2109()
{
  {
    init_simple_test("STT2109");
    static STRUCT_IF_C STT2109 lv;
    check2(sizeof(lv), 8, "sizeof(STT2109)");
    check2(__alignof__(lv), 4, "__alignof__(STT2109)");
    check_field_offset(lv, fa, 0, "STT2109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2109, STT2109)
//============================================================================


struct  STT2119  {
  int fa;
  __tsu64  :8;
};
//SIG(1 STT2119) C1{ Fi FL:8}



static void Test_STT2119()
{
  {
    init_simple_test("STT2119");
    static STRUCT_IF_C STT2119 lv;
    check2(sizeof(lv), 8, "sizeof(STT2119)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2119)");
    check_field_offset(lv, fa, 0, "STT2119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2119, STT2119)
//============================================================================


struct  STT2129  {
  int fa;
  unsigned int  :18;
};
//SIG(1 STT2129) C1{ Fi Fi:18}



static void Test_STT2129()
{
  {
    init_simple_test("STT2129");
    static STRUCT_IF_C STT2129 lv;
    check2(sizeof(lv), 8, "sizeof(STT2129)");
    check2(__alignof__(lv), 4, "__alignof__(STT2129)");
    check_field_offset(lv, fa, 0, "STT2129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2129, STT2129)
//============================================================================


struct  STT2139  {
  int fa;
  __tsu64  :18;
};
//SIG(1 STT2139) C1{ Fi FL:18}



static void Test_STT2139()
{
  {
    init_simple_test("STT2139");
    static STRUCT_IF_C STT2139 lv;
    check2(sizeof(lv), 8, "sizeof(STT2139)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2139)");
    check_field_offset(lv, fa, 0, "STT2139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2139, STT2139)
//============================================================================


struct  STT2149  {
  int fa;
  __tsu64  :48;
};
//SIG(1 STT2149) C1{ Fi FL:48}



static void Test_STT2149()
{
  {
    init_simple_test("STT2149");
    static STRUCT_IF_C STT2149 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2149)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT2149)");
    check_field_offset(lv, fa, 0, "STT2149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2149, STT2149)
//============================================================================


struct  STT2159  {
  int fa;
  unsigned char bf:3;
};
//SIG(1 STT2159) C1{ Fi Fc:3}



static void Test_STT2159()
{
  {
    init_simple_test("STT2159");
    static STRUCT_IF_C STT2159 lv;
    check2(sizeof(lv), 8, "sizeof(STT2159)");
    check2(__alignof__(lv), 4, "__alignof__(STT2159)");
    check_field_offset(lv, fa, 0, "STT2159.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2159");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2159, STT2159)
//============================================================================


struct  STT2169  {
  int fa;
  unsigned short bf:3;
};
//SIG(1 STT2169) C1{ Fi Fs:3}



static void Test_STT2169()
{
  {
    init_simple_test("STT2169");
    static STRUCT_IF_C STT2169 lv;
    check2(sizeof(lv), 8, "sizeof(STT2169)");
    check2(__alignof__(lv), 4, "__alignof__(STT2169)");
    check_field_offset(lv, fa, 0, "STT2169.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2169");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2169, STT2169)
//============================================================================


struct  STT2179  {
  int fa;
  unsigned int bf:3;
};
//SIG(1 STT2179) C1{ Fi Fi:3}



static void Test_STT2179()
{
  {
    init_simple_test("STT2179");
    static STRUCT_IF_C STT2179 lv;
    check2(sizeof(lv), 8, "sizeof(STT2179)");
    check2(__alignof__(lv), 4, "__alignof__(STT2179)");
    check_field_offset(lv, fa, 0, "STT2179.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2179");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2179, STT2179)
//============================================================================


struct  STT2189  {
  int fa;
  __tsu64 bf:3;
};
//SIG(1 STT2189) C1{ Fi FL:3}



static void Test_STT2189()
{
  {
    init_simple_test("STT2189");
    static STRUCT_IF_C STT2189 lv;
    check2(sizeof(lv), 8, "sizeof(STT2189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2189)");
    check_field_offset(lv, fa, 0, "STT2189.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT2189");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT2189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2189, STT2189)
//============================================================================


struct  STT2199  {
  int fa;
  unsigned short bf:8;
};
//SIG(1 STT2199) C1{ Fi Fs:8}



static void Test_STT2199()
{
  {
    init_simple_test("STT2199");
    static STRUCT_IF_C STT2199 lv;
    check2(sizeof(lv), 8, "sizeof(STT2199)");
    check2(__alignof__(lv), 4, "__alignof__(STT2199)");
    check_field_offset(lv, fa, 0, "STT2199.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2199");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2199, STT2199)
//============================================================================


struct  STT2209  {
  int fa;
  unsigned int bf:8;
};
//SIG(1 STT2209) C1{ Fi Fi:8}



static void Test_STT2209()
{
  {
    init_simple_test("STT2209");
    static STRUCT_IF_C STT2209 lv;
    check2(sizeof(lv), 8, "sizeof(STT2209)");
    check2(__alignof__(lv), 4, "__alignof__(STT2209)");
    check_field_offset(lv, fa, 0, "STT2209.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2209");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2209, STT2209)
//============================================================================


struct  STT2219  {
  int fa;
  __tsu64 bf:8;
};
//SIG(1 STT2219) C1{ Fi FL:8}



static void Test_STT2219()
{
  {
    init_simple_test("STT2219");
    static STRUCT_IF_C STT2219 lv;
    check2(sizeof(lv), 8, "sizeof(STT2219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2219)");
    check_field_offset(lv, fa, 0, "STT2219.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT2219");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT2219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2219, STT2219)
//============================================================================


struct  STT2229  {
  int fa;
  unsigned int bf:18;
};
//SIG(1 STT2229) C1{ Fi Fi:18}



static void Test_STT2229()
{
  {
    init_simple_test("STT2229");
    static STRUCT_IF_C STT2229 lv;
    check2(sizeof(lv), 8, "sizeof(STT2229)");
    check2(__alignof__(lv), 4, "__alignof__(STT2229)");
    check_field_offset(lv, fa, 0, "STT2229.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2229");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2229, STT2229)
//============================================================================


struct  STT2239  {
  int fa;
  __tsu64 bf:18;
};
//SIG(1 STT2239) C1{ Fi FL:18}



static void Test_STT2239()
{
  {
    init_simple_test("STT2239");
    static STRUCT_IF_C STT2239 lv;
    check2(sizeof(lv), 8, "sizeof(STT2239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2239)");
    check_field_offset(lv, fa, 0, "STT2239.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT2239");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT2239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2239, STT2239)
//============================================================================


struct  STT2249  {
  int fa;
  __tsu64 bf:48;
};
//SIG(1 STT2249) C1{ Fi FL:48}



static void Test_STT2249()
{
  {
    init_simple_test("STT2249");
    static STRUCT_IF_C STT2249 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT2249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT2249)");
    check_field_offset(lv, fa, 0, "STT2249.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT2249");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT2249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT2249, STT2249)
//============================================================================


struct  STT310  {
  long fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT310) C1{ Fl Fc:0 Fc}



static void Test_STT310()
{
  {
    init_simple_test("STT310");
    static STRUCT_IF_C STT310 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT310)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT310)");
    check_field_offset(lv, fa, 0, "STT310.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT310.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT310, STT310)
//============================================================================


struct  STT320  {
  long fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT320) C1{ Fl Fs:0 Fc}



static void Test_STT320()
{
  {
    init_simple_test("STT320");
    static STRUCT_IF_C STT320 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT320)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT320)");
    check_field_offset(lv, fa, 0, "STT320.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT320.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT320, STT320)
//============================================================================


struct  STT330  {
  long fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT330) C1{ Fl Fi:0 Fc}



static void Test_STT330()
{
  {
    init_simple_test("STT330");
    static STRUCT_IF_C STT330 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT330)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT330)");
    check_field_offset(lv, fa, 0, "STT330.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT330.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT330, STT330)
//============================================================================


struct  STT340  {
  long fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT340) C1{ Fl FL:0 Fc}



static void Test_STT340()
{
  {
    init_simple_test("STT340");
    static STRUCT_IF_C STT340 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT340)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT340)");
    check_field_offset(lv, fa, 0, "STT340.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT340.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT340, STT340)
//============================================================================


struct  STT350  {
  long fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT350) C1{ Fl Fc:3 Fc}



static void Test_STT350()
{
  {
    init_simple_test("STT350");
    static STRUCT_IF_C STT350 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT350)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT350)");
    check_field_offset(lv, fa, 0, "STT350.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT350.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT350, STT350)
//============================================================================


struct  STT360  {
  long fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT360) C1{ Fl Fs:3 Fc}



static void Test_STT360()
{
  {
    init_simple_test("STT360");
    static STRUCT_IF_C STT360 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT360)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT360)");
    check_field_offset(lv, fa, 0, "STT360.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT360.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT360, STT360)
//============================================================================


struct  STT370  {
  long fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT370) C1{ Fl Fi:3 Fc}



static void Test_STT370()
{
  {
    init_simple_test("STT370");
    static STRUCT_IF_C STT370 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT370)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT370)");
    check_field_offset(lv, fa, 0, "STT370.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT370.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT370, STT370)
//============================================================================


struct  STT380  {
  long fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT380) C1{ Fl FL:3 Fc}



static void Test_STT380()
{
  {
    init_simple_test("STT380");
    static STRUCT_IF_C STT380 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT380)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT380)");
    check_field_offset(lv, fa, 0, "STT380.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT380.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT380, STT380)
//============================================================================


struct  STT390  {
  long fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT390) C1{ Fl Fs:8 Fc}



static void Test_STT390()
{
  {
    init_simple_test("STT390");
    static STRUCT_IF_C STT390 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT390)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT390)");
    check_field_offset(lv, fa, 0, "STT390.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT390.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT390, STT390)
//============================================================================


struct  STT3100  {
  long fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT3100) C1{ Fl Fi:8 Fc}



static void Test_STT3100()
{
  {
    init_simple_test("STT3100");
    static STRUCT_IF_C STT3100 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3100)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3100)");
    check_field_offset(lv, fa, 0, "STT3100.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3100, STT3100)
//============================================================================


struct  STT3110  {
  long fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT3110) C1{ Fl FL:8 Fc}



static void Test_STT3110()
{
  {
    init_simple_test("STT3110");
    static STRUCT_IF_C STT3110 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3110)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3110)");
    check_field_offset(lv, fa, 0, "STT3110.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3110, STT3110)
//============================================================================


struct  STT3120  {
  long fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT3120) C1{ Fl Fi:18 Fc}



static void Test_STT3120()
{
  {
    init_simple_test("STT3120");
    static STRUCT_IF_C STT3120 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3120)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3120)");
    check_field_offset(lv, fa, 0, "STT3120.fa");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT3120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3120, STT3120)
//============================================================================


struct  STT3130  {
  long fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT3130) C1{ Fl FL:18 Fc}



static void Test_STT3130()
{
  {
    init_simple_test("STT3130");
    static STRUCT_IF_C STT3130 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3130)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3130)");
    check_field_offset(lv, fa, 0, "STT3130.fa");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT3130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3130, STT3130)
//============================================================================


struct  STT3140  {
  long fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT3140) C1{ Fl FL:48 Fc}



static void Test_STT3140()
{
  {
    init_simple_test("STT3140");
    static STRUCT_IF_C STT3140 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3140)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3140)");
    check_field_offset(lv, fa, 0, "STT3140.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT3140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3140, STT3140)
//============================================================================


struct  STT3150  {
  long fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT3150) C1{ Fl Fc:3 Fc}



static void Test_STT3150()
{
  {
    init_simple_test("STT3150");
    static STRUCT_IF_C STT3150 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3150)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3150)");
    check_field_offset(lv, fa, 0, "STT3150.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3150");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3150");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3150, STT3150)
//============================================================================


struct  STT3160  {
  long fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT3160) C1{ Fl Fs:3 Fc}



static void Test_STT3160()
{
  {
    init_simple_test("STT3160");
    static STRUCT_IF_C STT3160 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3160)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3160)");
    check_field_offset(lv, fa, 0, "STT3160.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3160");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3160");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3160, STT3160)
//============================================================================


struct  STT3170  {
  long fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT3170) C1{ Fl Fi:3 Fc}



static void Test_STT3170()
{
  {
    init_simple_test("STT3170");
    static STRUCT_IF_C STT3170 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3170)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3170)");
    check_field_offset(lv, fa, 0, "STT3170.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3170");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3170");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3170, STT3170)
//============================================================================


struct  STT3180  {
  long fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT3180) C1{ Fl FL:3 Fc}



static void Test_STT3180()
{
  {
    init_simple_test("STT3180");
    static STRUCT_IF_C STT3180 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3180)");
    check_field_offset(lv, fa, 0, "STT3180.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3180");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3180");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3180, STT3180)
//============================================================================


struct  STT3190  {
  long fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT3190) C1{ Fl Fs:8 Fc}



static void Test_STT3190()
{
  {
    init_simple_test("STT3190");
    static STRUCT_IF_C STT3190 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3190)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3190)");
    check_field_offset(lv, fa, 0, "STT3190.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3190");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3190");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3190, STT3190)
//============================================================================


struct  STT3200  {
  long fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT3200) C1{ Fl Fi:8 Fc}



static void Test_STT3200()
{
  {
    init_simple_test("STT3200");
    static STRUCT_IF_C STT3200 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3200)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3200)");
    check_field_offset(lv, fa, 0, "STT3200.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3200");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3200");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3200, STT3200)
//============================================================================


struct  STT3210  {
  long fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT3210) C1{ Fl FL:8 Fc}



static void Test_STT3210()
{
  {
    init_simple_test("STT3210");
    static STRUCT_IF_C STT3210 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3210)");
    check_field_offset(lv, fa, 0, "STT3210.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3210");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3210");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT3210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3210, STT3210)
//============================================================================


struct  STT3220  {
  long fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT3220) C1{ Fl Fi:18 Fc}



static void Test_STT3220()
{
  {
    init_simple_test("STT3220");
    static STRUCT_IF_C STT3220 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3220)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3220)");
    check_field_offset(lv, fa, 0, "STT3220.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3220");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3220");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT3220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3220, STT3220)
//============================================================================


struct  STT3230  {
  long fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT3230) C1{ Fl FL:18 Fc}



static void Test_STT3230()
{
  {
    init_simple_test("STT3230");
    static STRUCT_IF_C STT3230 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3230)");
    check_field_offset(lv, fa, 0, "STT3230.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3230");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3230");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT3230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3230, STT3230)
//============================================================================


struct  STT3240  {
  long fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT3240) C1{ Fl FL:48 Fc}



static void Test_STT3240()
{
  {
    init_simple_test("STT3240");
    static STRUCT_IF_C STT3240 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3240)");
    check_field_offset(lv, fa, 0, "STT3240.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3240");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3240");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT3240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3240, STT3240)
//============================================================================


struct  STT311  {
  long fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT311) C1{ Fl Fc:0 Fs}



static void Test_STT311()
{
  {
    init_simple_test("STT311");
    static STRUCT_IF_C STT311 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT311)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT311)");
    check_field_offset(lv, fa, 0, "STT311.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT311.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT311, STT311)
//============================================================================


struct  STT321  {
  long fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT321) C1{ Fl Fs:0 Fs}



static void Test_STT321()
{
  {
    init_simple_test("STT321");
    static STRUCT_IF_C STT321 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT321)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT321)");
    check_field_offset(lv, fa, 0, "STT321.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT321.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT321, STT321)
//============================================================================


struct  STT331  {
  long fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT331) C1{ Fl Fi:0 Fs}



static void Test_STT331()
{
  {
    init_simple_test("STT331");
    static STRUCT_IF_C STT331 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT331)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT331)");
    check_field_offset(lv, fa, 0, "STT331.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT331.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT331, STT331)
//============================================================================


struct  STT341  {
  long fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT341) C1{ Fl FL:0 Fs}



static void Test_STT341()
{
  {
    init_simple_test("STT341");
    static STRUCT_IF_C STT341 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT341)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT341)");
    check_field_offset(lv, fa, 0, "STT341.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT341.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT341, STT341)
//============================================================================


struct  STT351  {
  long fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT351) C1{ Fl Fc:3 Fs}



static void Test_STT351()
{
  {
    init_simple_test("STT351");
    static STRUCT_IF_C STT351 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT351)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT351)");
    check_field_offset(lv, fa, 0, "STT351.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT351.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT351, STT351)
//============================================================================


struct  STT361  {
  long fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT361) C1{ Fl Fs:3 Fs}



static void Test_STT361()
{
  {
    init_simple_test("STT361");
    static STRUCT_IF_C STT361 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT361)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT361)");
    check_field_offset(lv, fa, 0, "STT361.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT361.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT361, STT361)
//============================================================================


struct  STT371  {
  long fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT371) C1{ Fl Fi:3 Fs}



static void Test_STT371()
{
  {
    init_simple_test("STT371");
    static STRUCT_IF_C STT371 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT371)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT371)");
    check_field_offset(lv, fa, 0, "STT371.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT371.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT371, STT371)
//============================================================================


struct  STT381  {
  long fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT381) C1{ Fl FL:3 Fs}



static void Test_STT381()
{
  {
    init_simple_test("STT381");
    static STRUCT_IF_C STT381 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT381)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT381)");
    check_field_offset(lv, fa, 0, "STT381.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT381.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT381, STT381)
//============================================================================


struct  STT391  {
  long fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT391) C1{ Fl Fs:8 Fs}



static void Test_STT391()
{
  {
    init_simple_test("STT391");
    static STRUCT_IF_C STT391 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT391)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT391)");
    check_field_offset(lv, fa, 0, "STT391.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT391.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT391, STT391)
//============================================================================


struct  STT3101  {
  long fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT3101) C1{ Fl Fi:8 Fs}



static void Test_STT3101()
{
  {
    init_simple_test("STT3101");
    static STRUCT_IF_C STT3101 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3101)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3101)");
    check_field_offset(lv, fa, 0, "STT3101.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3101, STT3101)
//============================================================================


struct  STT3111  {
  long fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT3111) C1{ Fl FL:8 Fs}



static void Test_STT3111()
{
  {
    init_simple_test("STT3111");
    static STRUCT_IF_C STT3111 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3111)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3111)");
    check_field_offset(lv, fa, 0, "STT3111.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3111, STT3111)
//============================================================================


struct  STT3121  {
  long fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT3121) C1{ Fl Fi:18 Fs}



static void Test_STT3121()
{
  {
    init_simple_test("STT3121");
    static STRUCT_IF_C STT3121 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3121)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3121)");
    check_field_offset(lv, fa, 0, "STT3121.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3121, STT3121)
//============================================================================


struct  STT3131  {
  long fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT3131) C1{ Fl FL:18 Fs}



static void Test_STT3131()
{
  {
    init_simple_test("STT3131");
    static STRUCT_IF_C STT3131 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3131)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3131)");
    check_field_offset(lv, fa, 0, "STT3131.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3131, STT3131)
//============================================================================


struct  STT3141  {
  long fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT3141) C1{ Fl FL:48 Fs}



static void Test_STT3141()
{
  {
    init_simple_test("STT3141");
    static STRUCT_IF_C STT3141 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3141)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3141)");
    check_field_offset(lv, fa, 0, "STT3141.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT3141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3141, STT3141)
//============================================================================


struct  STT3151  {
  long fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT3151) C1{ Fl Fc:3 Fs}



static void Test_STT3151()
{
  {
    init_simple_test("STT3151");
    static STRUCT_IF_C STT3151 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3151)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3151)");
    check_field_offset(lv, fa, 0, "STT3151.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3151");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3151");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3151, STT3151)
//============================================================================


struct  STT3161  {
  long fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT3161) C1{ Fl Fs:3 Fs}



static void Test_STT3161()
{
  {
    init_simple_test("STT3161");
    static STRUCT_IF_C STT3161 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3161)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3161)");
    check_field_offset(lv, fa, 0, "STT3161.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3161");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3161");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3161, STT3161)
//============================================================================


struct  STT3171  {
  long fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT3171) C1{ Fl Fi:3 Fs}



static void Test_STT3171()
{
  {
    init_simple_test("STT3171");
    static STRUCT_IF_C STT3171 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3171)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3171)");
    check_field_offset(lv, fa, 0, "STT3171.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3171");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3171");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3171, STT3171)
//============================================================================


struct  STT3181  {
  long fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT3181) C1{ Fl FL:3 Fs}



static void Test_STT3181()
{
  {
    init_simple_test("STT3181");
    static STRUCT_IF_C STT3181 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3181)");
    check_field_offset(lv, fa, 0, "STT3181.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3181");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3181");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3181, STT3181)
//============================================================================


struct  STT3191  {
  long fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT3191) C1{ Fl Fs:8 Fs}



static void Test_STT3191()
{
  {
    init_simple_test("STT3191");
    static STRUCT_IF_C STT3191 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3191)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3191)");
    check_field_offset(lv, fa, 0, "STT3191.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3191");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3191");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3191, STT3191)
//============================================================================


struct  STT3201  {
  long fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT3201) C1{ Fl Fi:8 Fs}



static void Test_STT3201()
{
  {
    init_simple_test("STT3201");
    static STRUCT_IF_C STT3201 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3201)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3201)");
    check_field_offset(lv, fa, 0, "STT3201.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3201");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3201");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3201, STT3201)
//============================================================================


struct  STT3211  {
  long fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT3211) C1{ Fl FL:8 Fs}



static void Test_STT3211()
{
  {
    init_simple_test("STT3211");
    static STRUCT_IF_C STT3211 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3211)");
    check_field_offset(lv, fa, 0, "STT3211.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3211");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3211");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT3211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3211, STT3211)
//============================================================================


struct  STT3221  {
  long fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT3221) C1{ Fl Fi:18 Fs}



static void Test_STT3221()
{
  {
    init_simple_test("STT3221");
    static STRUCT_IF_C STT3221 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3221)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3221)");
    check_field_offset(lv, fa, 0, "STT3221.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3221");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3221");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3221, STT3221)
//============================================================================


struct  STT3231  {
  long fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT3231) C1{ Fl FL:18 Fs}



static void Test_STT3231()
{
  {
    init_simple_test("STT3231");
    static STRUCT_IF_C STT3231 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3231)");
    check_field_offset(lv, fa, 0, "STT3231.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3231");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3231");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3231, STT3231)
//============================================================================


struct  STT3241  {
  long fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT3241) C1{ Fl FL:48 Fs}



static void Test_STT3241()
{
  {
    init_simple_test("STT3241");
    static STRUCT_IF_C STT3241 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3241)");
    check_field_offset(lv, fa, 0, "STT3241.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3241");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3241");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT3241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3241, STT3241)
//============================================================================


struct  STT312  {
  long fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT312) C1{ Fl Fc:0 Fi}



static void Test_STT312()
{
  {
    init_simple_test("STT312");
    static STRUCT_IF_C STT312 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT312)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT312)");
    check_field_offset(lv, fa, 0, "STT312.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT312.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT312, STT312)
//============================================================================


struct  STT322  {
  long fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT322) C1{ Fl Fs:0 Fi}



static void Test_STT322()
{
  {
    init_simple_test("STT322");
    static STRUCT_IF_C STT322 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT322)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT322)");
    check_field_offset(lv, fa, 0, "STT322.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT322.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT322, STT322)
//============================================================================


struct  STT332  {
  long fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT332) C1{ Fl Fi:0 Fi}



static void Test_STT332()
{
  {
    init_simple_test("STT332");
    static STRUCT_IF_C STT332 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT332)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT332)");
    check_field_offset(lv, fa, 0, "STT332.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT332.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT332, STT332)
//============================================================================


struct  STT342  {
  long fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT342) C1{ Fl FL:0 Fi}



static void Test_STT342()
{
  {
    init_simple_test("STT342");
    static STRUCT_IF_C STT342 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT342)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT342)");
    check_field_offset(lv, fa, 0, "STT342.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT342.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT342, STT342)
//============================================================================


struct  STT352  {
  long fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT352) C1{ Fl Fc:3 Fi}



static void Test_STT352()
{
  {
    init_simple_test("STT352");
    static STRUCT_IF_C STT352 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT352)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT352)");
    check_field_offset(lv, fa, 0, "STT352.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT352.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT352, STT352)
//============================================================================


struct  STT362  {
  long fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT362) C1{ Fl Fs:3 Fi}



static void Test_STT362()
{
  {
    init_simple_test("STT362");
    static STRUCT_IF_C STT362 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT362)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT362)");
    check_field_offset(lv, fa, 0, "STT362.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT362.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT362, STT362)
//============================================================================


struct  STT372  {
  long fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT372) C1{ Fl Fi:3 Fi}



static void Test_STT372()
{
  {
    init_simple_test("STT372");
    static STRUCT_IF_C STT372 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT372)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT372)");
    check_field_offset(lv, fa, 0, "STT372.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT372.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT372, STT372)
//============================================================================


struct  STT382  {
  long fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT382) C1{ Fl FL:3 Fi}



static void Test_STT382()
{
  {
    init_simple_test("STT382");
    static STRUCT_IF_C STT382 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT382)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT382)");
    check_field_offset(lv, fa, 0, "STT382.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT382.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT382, STT382)
//============================================================================


struct  STT392  {
  long fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT392) C1{ Fl Fs:8 Fi}



static void Test_STT392()
{
  {
    init_simple_test("STT392");
    static STRUCT_IF_C STT392 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT392)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT392)");
    check_field_offset(lv, fa, 0, "STT392.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT392.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT392, STT392)
//============================================================================


struct  STT3102  {
  long fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT3102) C1{ Fl Fi:8 Fi}



static void Test_STT3102()
{
  {
    init_simple_test("STT3102");
    static STRUCT_IF_C STT3102 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3102)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3102)");
    check_field_offset(lv, fa, 0, "STT3102.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3102, STT3102)
//============================================================================


struct  STT3112  {
  long fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT3112) C1{ Fl FL:8 Fi}



static void Test_STT3112()
{
  {
    init_simple_test("STT3112");
    static STRUCT_IF_C STT3112 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3112)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3112)");
    check_field_offset(lv, fa, 0, "STT3112.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3112, STT3112)
//============================================================================


struct  STT3122  {
  long fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT3122) C1{ Fl Fi:18 Fi}



static void Test_STT3122()
{
  {
    init_simple_test("STT3122");
    static STRUCT_IF_C STT3122 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3122)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3122)");
    check_field_offset(lv, fa, 0, "STT3122.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3122, STT3122)
//============================================================================


struct  STT3132  {
  long fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT3132) C1{ Fl FL:18 Fi}



static void Test_STT3132()
{
  {
    init_simple_test("STT3132");
    static STRUCT_IF_C STT3132 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3132)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3132)");
    check_field_offset(lv, fa, 0, "STT3132.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3132, STT3132)
//============================================================================


struct  STT3142  {
  long fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT3142) C1{ Fl FL:48 Fi}



static void Test_STT3142()
{
  {
    init_simple_test("STT3142");
    static STRUCT_IF_C STT3142 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3142)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3142)");
    check_field_offset(lv, fa, 0, "STT3142.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3142, STT3142)
//============================================================================


struct  STT3152  {
  long fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT3152) C1{ Fl Fc:3 Fi}



static void Test_STT3152()
{
  {
    init_simple_test("STT3152");
    static STRUCT_IF_C STT3152 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3152)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3152)");
    check_field_offset(lv, fa, 0, "STT3152.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3152");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3152");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3152, STT3152)
//============================================================================


struct  STT3162  {
  long fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT3162) C1{ Fl Fs:3 Fi}



static void Test_STT3162()
{
  {
    init_simple_test("STT3162");
    static STRUCT_IF_C STT3162 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3162)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3162)");
    check_field_offset(lv, fa, 0, "STT3162.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3162");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3162");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3162, STT3162)
//============================================================================


struct  STT3172  {
  long fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT3172) C1{ Fl Fi:3 Fi}



static void Test_STT3172()
{
  {
    init_simple_test("STT3172");
    static STRUCT_IF_C STT3172 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3172)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3172)");
    check_field_offset(lv, fa, 0, "STT3172.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3172");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3172");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3172, STT3172)
//============================================================================


struct  STT3182  {
  long fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT3182) C1{ Fl FL:3 Fi}



static void Test_STT3182()
{
  {
    init_simple_test("STT3182");
    static STRUCT_IF_C STT3182 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3182)");
    check_field_offset(lv, fa, 0, "STT3182.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3182");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3182");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3182, STT3182)
//============================================================================


struct  STT3192  {
  long fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT3192) C1{ Fl Fs:8 Fi}



static void Test_STT3192()
{
  {
    init_simple_test("STT3192");
    static STRUCT_IF_C STT3192 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3192)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3192)");
    check_field_offset(lv, fa, 0, "STT3192.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3192");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3192");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3192, STT3192)
//============================================================================


struct  STT3202  {
  long fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT3202) C1{ Fl Fi:8 Fi}



static void Test_STT3202()
{
  {
    init_simple_test("STT3202");
    static STRUCT_IF_C STT3202 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3202)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3202)");
    check_field_offset(lv, fa, 0, "STT3202.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3202");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3202");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3202, STT3202)
//============================================================================


struct  STT3212  {
  long fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT3212) C1{ Fl FL:8 Fi}



static void Test_STT3212()
{
  {
    init_simple_test("STT3212");
    static STRUCT_IF_C STT3212 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3212)");
    check_field_offset(lv, fa, 0, "STT3212.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3212");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3212");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3212, STT3212)
//============================================================================


struct  STT3222  {
  long fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT3222) C1{ Fl Fi:18 Fi}



static void Test_STT3222()
{
  {
    init_simple_test("STT3222");
    static STRUCT_IF_C STT3222 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3222)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3222)");
    check_field_offset(lv, fa, 0, "STT3222.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3222");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3222");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3222, STT3222)
//============================================================================


struct  STT3232  {
  long fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT3232) C1{ Fl FL:18 Fi}



static void Test_STT3232()
{
  {
    init_simple_test("STT3232");
    static STRUCT_IF_C STT3232 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3232)");
    check_field_offset(lv, fa, 0, "STT3232.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3232");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3232");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3232, STT3232)
//============================================================================


struct  STT3242  {
  long fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT3242) C1{ Fl FL:48 Fi}



static void Test_STT3242()
{
  {
    init_simple_test("STT3242");
    static STRUCT_IF_C STT3242 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3242)");
    check_field_offset(lv, fa, 0, "STT3242.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3242");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3242");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3242, STT3242)
//============================================================================


struct  STT313  {
  long fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT313) C1{ Fl Fc:0 Fl}



static void Test_STT313()
{
  {
    init_simple_test("STT313");
    static STRUCT_IF_C STT313 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT313)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT313)");
    check_field_offset(lv, fa, 0, "STT313.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT313.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT313, STT313)
//============================================================================


struct  STT323  {
  long fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT323) C1{ Fl Fs:0 Fl}



static void Test_STT323()
{
  {
    init_simple_test("STT323");
    static STRUCT_IF_C STT323 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT323)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT323)");
    check_field_offset(lv, fa, 0, "STT323.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT323.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT323, STT323)
//============================================================================


struct  STT333  {
  long fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT333) C1{ Fl Fi:0 Fl}



static void Test_STT333()
{
  {
    init_simple_test("STT333");
    static STRUCT_IF_C STT333 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT333)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT333)");
    check_field_offset(lv, fa, 0, "STT333.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT333.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT333, STT333)
//============================================================================


struct  STT343  {
  long fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT343) C1{ Fl FL:0 Fl}



static void Test_STT343()
{
  {
    init_simple_test("STT343");
    static STRUCT_IF_C STT343 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT343)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT343)");
    check_field_offset(lv, fa, 0, "STT343.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT343.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT343, STT343)
//============================================================================


struct  STT353  {
  long fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT353) C1{ Fl Fc:3 Fl}



static void Test_STT353()
{
  {
    init_simple_test("STT353");
    static STRUCT_IF_C STT353 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT353)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT353)");
    check_field_offset(lv, fa, 0, "STT353.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT353.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT353, STT353)
//============================================================================


struct  STT363  {
  long fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT363) C1{ Fl Fs:3 Fl}



static void Test_STT363()
{
  {
    init_simple_test("STT363");
    static STRUCT_IF_C STT363 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT363)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT363)");
    check_field_offset(lv, fa, 0, "STT363.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT363.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT363, STT363)
//============================================================================


struct  STT373  {
  long fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT373) C1{ Fl Fi:3 Fl}



static void Test_STT373()
{
  {
    init_simple_test("STT373");
    static STRUCT_IF_C STT373 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT373)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT373)");
    check_field_offset(lv, fa, 0, "STT373.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT373.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT373, STT373)
//============================================================================


struct  STT383  {
  long fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT383) C1{ Fl FL:3 Fl}



static void Test_STT383()
{
  {
    init_simple_test("STT383");
    static STRUCT_IF_C STT383 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT383)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT383)");
    check_field_offset(lv, fa, 0, "STT383.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT383.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT383, STT383)
//============================================================================


struct  STT393  {
  long fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT393) C1{ Fl Fs:8 Fl}



static void Test_STT393()
{
  {
    init_simple_test("STT393");
    static STRUCT_IF_C STT393 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT393)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT393)");
    check_field_offset(lv, fa, 0, "STT393.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT393.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT393, STT393)
//============================================================================


struct  STT3103  {
  long fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT3103) C1{ Fl Fi:8 Fl}



static void Test_STT3103()
{
  {
    init_simple_test("STT3103");
    static STRUCT_IF_C STT3103 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3103)");
    check_field_offset(lv, fa, 0, "STT3103.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3103, STT3103)
//============================================================================


struct  STT3113  {
  long fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT3113) C1{ Fl FL:8 Fl}



static void Test_STT3113()
{
  {
    init_simple_test("STT3113");
    static STRUCT_IF_C STT3113 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3113)");
    check_field_offset(lv, fa, 0, "STT3113.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3113, STT3113)
//============================================================================


struct  STT3123  {
  long fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT3123) C1{ Fl Fi:18 Fl}



static void Test_STT3123()
{
  {
    init_simple_test("STT3123");
    static STRUCT_IF_C STT3123 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3123)");
    check_field_offset(lv, fa, 0, "STT3123.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3123, STT3123)
//============================================================================


struct  STT3133  {
  long fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT3133) C1{ Fl FL:18 Fl}



static void Test_STT3133()
{
  {
    init_simple_test("STT3133");
    static STRUCT_IF_C STT3133 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3133)");
    check_field_offset(lv, fa, 0, "STT3133.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3133, STT3133)
//============================================================================


struct  STT3143  {
  long fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT3143) C1{ Fl FL:48 Fl}



static void Test_STT3143()
{
  {
    init_simple_test("STT3143");
    static STRUCT_IF_C STT3143 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3143)");
    check_field_offset(lv, fa, 0, "STT3143.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3143, STT3143)
//============================================================================


struct  STT3153  {
  long fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT3153) C1{ Fl Fc:3 Fl}



static void Test_STT3153()
{
  {
    init_simple_test("STT3153");
    static STRUCT_IF_C STT3153 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3153)");
    check_field_offset(lv, fa, 0, "STT3153.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3153");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3153");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3153, STT3153)
//============================================================================


struct  STT3163  {
  long fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT3163) C1{ Fl Fs:3 Fl}



static void Test_STT3163()
{
  {
    init_simple_test("STT3163");
    static STRUCT_IF_C STT3163 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3163)");
    check_field_offset(lv, fa, 0, "STT3163.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3163");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3163");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3163, STT3163)
//============================================================================


struct  STT3173  {
  long fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT3173) C1{ Fl Fi:3 Fl}



static void Test_STT3173()
{
  {
    init_simple_test("STT3173");
    static STRUCT_IF_C STT3173 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3173)");
    check_field_offset(lv, fa, 0, "STT3173.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3173");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3173");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3173, STT3173)
//============================================================================


struct  STT3183  {
  long fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT3183) C1{ Fl FL:3 Fl}



static void Test_STT3183()
{
  {
    init_simple_test("STT3183");
    static STRUCT_IF_C STT3183 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3183)");
    check_field_offset(lv, fa, 0, "STT3183.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3183");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3183");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3183, STT3183)
//============================================================================


struct  STT3193  {
  long fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT3193) C1{ Fl Fs:8 Fl}



static void Test_STT3193()
{
  {
    init_simple_test("STT3193");
    static STRUCT_IF_C STT3193 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3193)");
    check_field_offset(lv, fa, 0, "STT3193.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3193");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3193");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3193, STT3193)
//============================================================================


struct  STT3203  {
  long fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT3203) C1{ Fl Fi:8 Fl}



static void Test_STT3203()
{
  {
    init_simple_test("STT3203");
    static STRUCT_IF_C STT3203 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3203)");
    check_field_offset(lv, fa, 0, "STT3203.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3203");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3203");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3203, STT3203)
//============================================================================


struct  STT3213  {
  long fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT3213) C1{ Fl FL:8 Fl}



static void Test_STT3213()
{
  {
    init_simple_test("STT3213");
    static STRUCT_IF_C STT3213 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3213)");
    check_field_offset(lv, fa, 0, "STT3213.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3213");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3213");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3213, STT3213)
//============================================================================


struct  STT3223  {
  long fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT3223) C1{ Fl Fi:18 Fl}



static void Test_STT3223()
{
  {
    init_simple_test("STT3223");
    static STRUCT_IF_C STT3223 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3223)");
    check_field_offset(lv, fa, 0, "STT3223.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3223");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3223");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3223, STT3223)
//============================================================================


struct  STT3233  {
  long fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT3233) C1{ Fl FL:18 Fl}



static void Test_STT3233()
{
  {
    init_simple_test("STT3233");
    static STRUCT_IF_C STT3233 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3233)");
    check_field_offset(lv, fa, 0, "STT3233.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3233");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3233");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3233, STT3233)
//============================================================================


struct  STT3243  {
  long fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT3243) C1{ Fl FL:48 Fl}



static void Test_STT3243()
{
  {
    init_simple_test("STT3243");
    static STRUCT_IF_C STT3243 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3243)");
    check_field_offset(lv, fa, 0, "STT3243.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3243");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3243");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3243, STT3243)
//============================================================================


struct  STT314  {
  long fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT314) C1{ Fl Fc:0 FL}



static void Test_STT314()
{
  {
    init_simple_test("STT314");
    static STRUCT_IF_C STT314 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT314)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT314)");
    check_field_offset(lv, fa, 0, "STT314.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT314.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT314, STT314)
//============================================================================


struct  STT324  {
  long fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT324) C1{ Fl Fs:0 FL}



static void Test_STT324()
{
  {
    init_simple_test("STT324");
    static STRUCT_IF_C STT324 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT324)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT324)");
    check_field_offset(lv, fa, 0, "STT324.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT324.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT324, STT324)
//============================================================================


struct  STT334  {
  long fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT334) C1{ Fl Fi:0 FL}



static void Test_STT334()
{
  {
    init_simple_test("STT334");
    static STRUCT_IF_C STT334 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT334)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT334)");
    check_field_offset(lv, fa, 0, "STT334.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT334.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT334, STT334)
//============================================================================


struct  STT344  {
  long fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT344) C1{ Fl FL:0 FL}



static void Test_STT344()
{
  {
    init_simple_test("STT344");
    static STRUCT_IF_C STT344 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT344)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT344)");
    check_field_offset(lv, fa, 0, "STT344.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT344.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT344, STT344)
//============================================================================


struct  STT354  {
  long fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT354) C1{ Fl Fc:3 FL}



static void Test_STT354()
{
  {
    init_simple_test("STT354");
    static STRUCT_IF_C STT354 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT354)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT354)");
    check_field_offset(lv, fa, 0, "STT354.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT354.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT354, STT354)
//============================================================================


struct  STT364  {
  long fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT364) C1{ Fl Fs:3 FL}



static void Test_STT364()
{
  {
    init_simple_test("STT364");
    static STRUCT_IF_C STT364 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT364)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT364)");
    check_field_offset(lv, fa, 0, "STT364.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT364.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT364, STT364)
//============================================================================


struct  STT374  {
  long fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT374) C1{ Fl Fi:3 FL}



static void Test_STT374()
{
  {
    init_simple_test("STT374");
    static STRUCT_IF_C STT374 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT374)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT374)");
    check_field_offset(lv, fa, 0, "STT374.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT374.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT374, STT374)
//============================================================================


struct  STT384  {
  long fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT384) C1{ Fl FL:3 FL}



static void Test_STT384()
{
  {
    init_simple_test("STT384");
    static STRUCT_IF_C STT384 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT384)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT384)");
    check_field_offset(lv, fa, 0, "STT384.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT384.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT384, STT384)
//============================================================================


struct  STT394  {
  long fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT394) C1{ Fl Fs:8 FL}



static void Test_STT394()
{
  {
    init_simple_test("STT394");
    static STRUCT_IF_C STT394 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT394)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT394)");
    check_field_offset(lv, fa, 0, "STT394.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT394.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT394, STT394)
//============================================================================


struct  STT3104  {
  long fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT3104) C1{ Fl Fi:8 FL}



static void Test_STT3104()
{
  {
    init_simple_test("STT3104");
    static STRUCT_IF_C STT3104 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3104)");
    check_field_offset(lv, fa, 0, "STT3104.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3104, STT3104)
//============================================================================


struct  STT3114  {
  long fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT3114) C1{ Fl FL:8 FL}



static void Test_STT3114()
{
  {
    init_simple_test("STT3114");
    static STRUCT_IF_C STT3114 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3114)");
    check_field_offset(lv, fa, 0, "STT3114.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3114, STT3114)
//============================================================================


struct  STT3124  {
  long fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT3124) C1{ Fl Fi:18 FL}



static void Test_STT3124()
{
  {
    init_simple_test("STT3124");
    static STRUCT_IF_C STT3124 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3124)");
    check_field_offset(lv, fa, 0, "STT3124.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3124, STT3124)
//============================================================================


struct  STT3134  {
  long fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT3134) C1{ Fl FL:18 FL}



static void Test_STT3134()
{
  {
    init_simple_test("STT3134");
    static STRUCT_IF_C STT3134 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3134)");
    check_field_offset(lv, fa, 0, "STT3134.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3134, STT3134)
//============================================================================


struct  STT3144  {
  long fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT3144) C1{ Fl FL:48 FL}



static void Test_STT3144()
{
  {
    init_simple_test("STT3144");
    static STRUCT_IF_C STT3144 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT3144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3144)");
    check_field_offset(lv, fa, 0, "STT3144.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3144, STT3144)
//============================================================================


struct  STT3154  {
  long fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT3154) C1{ Fl Fc:3 FL}



static void Test_STT3154()
{
  {
    init_simple_test("STT3154");
    static STRUCT_IF_C STT3154 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3154)");
    check_field_offset(lv, fa, 0, "STT3154.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3154");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3154");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3154, STT3154)
//============================================================================


struct  STT3164  {
  long fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT3164) C1{ Fl Fs:3 FL}



static void Test_STT3164()
{
  {
    init_simple_test("STT3164");
    static STRUCT_IF_C STT3164 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3164)");
    check_field_offset(lv, fa, 0, "STT3164.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3164");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3164");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3164, STT3164)
//============================================================================


struct  STT3174  {
  long fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT3174) C1{ Fl Fi:3 FL}



static void Test_STT3174()
{
  {
    init_simple_test("STT3174");
    static STRUCT_IF_C STT3174 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3174)");
    check_field_offset(lv, fa, 0, "STT3174.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3174");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3174");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3174, STT3174)
//============================================================================


struct  STT3184  {
  long fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT3184) C1{ Fl FL:3 FL}



static void Test_STT3184()
{
  {
    init_simple_test("STT3184");
    static STRUCT_IF_C STT3184 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3184)");
    check_field_offset(lv, fa, 0, "STT3184.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3184");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3184");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3184, STT3184)
//============================================================================


struct  STT3194  {
  long fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT3194) C1{ Fl Fs:8 FL}



static void Test_STT3194()
{
  {
    init_simple_test("STT3194");
    static STRUCT_IF_C STT3194 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3194)");
    check_field_offset(lv, fa, 0, "STT3194.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3194");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3194");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3194, STT3194)
//============================================================================


struct  STT3204  {
  long fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT3204) C1{ Fl Fi:8 FL}



static void Test_STT3204()
{
  {
    init_simple_test("STT3204");
    static STRUCT_IF_C STT3204 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3204)");
    check_field_offset(lv, fa, 0, "STT3204.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3204");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3204");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3204, STT3204)
//============================================================================


struct  STT3214  {
  long fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT3214) C1{ Fl FL:8 FL}



static void Test_STT3214()
{
  {
    init_simple_test("STT3214");
    static STRUCT_IF_C STT3214 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3214)");
    check_field_offset(lv, fa, 0, "STT3214.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3214");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3214");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3214, STT3214)
//============================================================================


struct  STT3224  {
  long fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT3224) C1{ Fl Fi:18 FL}



static void Test_STT3224()
{
  {
    init_simple_test("STT3224");
    static STRUCT_IF_C STT3224 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3224)");
    check_field_offset(lv, fa, 0, "STT3224.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3224");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3224");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3224, STT3224)
//============================================================================


struct  STT3234  {
  long fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT3234) C1{ Fl FL:18 FL}



static void Test_STT3234()
{
  {
    init_simple_test("STT3234");
    static STRUCT_IF_C STT3234 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3234)");
    check_field_offset(lv, fa, 0, "STT3234.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3234");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3234");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3234, STT3234)
//============================================================================


struct  STT3244  {
  long fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT3244) C1{ Fl FL:48 FL}



static void Test_STT3244()
{
  {
    init_simple_test("STT3244");
    static STRUCT_IF_C STT3244 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT3244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3244)");
    check_field_offset(lv, fa, 0, "STT3244.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3244");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3244");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3244, STT3244)
//============================================================================


struct  STT315  {
  long fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT315) C1{ Fl Fc:0 Fp}



static void Test_STT315()
{
  {
    init_simple_test("STT315");
    static STRUCT_IF_C STT315 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT315)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT315)");
    check_field_offset(lv, fa, 0, "STT315.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT315.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT315, STT315)
//============================================================================


struct  STT325  {
  long fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT325) C1{ Fl Fs:0 Fp}



static void Test_STT325()
{
  {
    init_simple_test("STT325");
    static STRUCT_IF_C STT325 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT325)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT325)");
    check_field_offset(lv, fa, 0, "STT325.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT325.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT325, STT325)
//============================================================================


struct  STT335  {
  long fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT335) C1{ Fl Fi:0 Fp}



static void Test_STT335()
{
  {
    init_simple_test("STT335");
    static STRUCT_IF_C STT335 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT335)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT335)");
    check_field_offset(lv, fa, 0, "STT335.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT335.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT335, STT335)
//============================================================================


struct  STT345  {
  long fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT345) C1{ Fl FL:0 Fp}



static void Test_STT345()
{
  {
    init_simple_test("STT345");
    static STRUCT_IF_C STT345 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT345)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT345)");
    check_field_offset(lv, fa, 0, "STT345.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT345.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT345, STT345)
//============================================================================


struct  STT355  {
  long fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT355) C1{ Fl Fc:3 Fp}



static void Test_STT355()
{
  {
    init_simple_test("STT355");
    static STRUCT_IF_C STT355 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT355)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT355)");
    check_field_offset(lv, fa, 0, "STT355.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT355.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT355, STT355)
//============================================================================


struct  STT365  {
  long fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT365) C1{ Fl Fs:3 Fp}



static void Test_STT365()
{
  {
    init_simple_test("STT365");
    static STRUCT_IF_C STT365 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT365)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT365)");
    check_field_offset(lv, fa, 0, "STT365.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT365.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT365, STT365)
//============================================================================


struct  STT375  {
  long fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT375) C1{ Fl Fi:3 Fp}



static void Test_STT375()
{
  {
    init_simple_test("STT375");
    static STRUCT_IF_C STT375 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT375)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT375)");
    check_field_offset(lv, fa, 0, "STT375.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT375.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT375, STT375)
//============================================================================


struct  STT385  {
  long fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT385) C1{ Fl FL:3 Fp}



static void Test_STT385()
{
  {
    init_simple_test("STT385");
    static STRUCT_IF_C STT385 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT385)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT385)");
    check_field_offset(lv, fa, 0, "STT385.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT385.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT385, STT385)
//============================================================================


struct  STT395  {
  long fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT395) C1{ Fl Fs:8 Fp}



static void Test_STT395()
{
  {
    init_simple_test("STT395");
    static STRUCT_IF_C STT395 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT395)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT395)");
    check_field_offset(lv, fa, 0, "STT395.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT395.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT395, STT395)
//============================================================================


struct  STT3105  {
  long fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT3105) C1{ Fl Fi:8 Fp}



static void Test_STT3105()
{
  {
    init_simple_test("STT3105");
    static STRUCT_IF_C STT3105 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3105)");
    check_field_offset(lv, fa, 0, "STT3105.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3105, STT3105)
//============================================================================


struct  STT3115  {
  long fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT3115) C1{ Fl FL:8 Fp}



static void Test_STT3115()
{
  {
    init_simple_test("STT3115");
    static STRUCT_IF_C STT3115 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3115)");
    check_field_offset(lv, fa, 0, "STT3115.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3115, STT3115)
//============================================================================


struct  STT3125  {
  long fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT3125) C1{ Fl Fi:18 Fp}



static void Test_STT3125()
{
  {
    init_simple_test("STT3125");
    static STRUCT_IF_C STT3125 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3125)");
    check_field_offset(lv, fa, 0, "STT3125.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3125, STT3125)
//============================================================================


struct  STT3135  {
  long fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT3135) C1{ Fl FL:18 Fp}



static void Test_STT3135()
{
  {
    init_simple_test("STT3135");
    static STRUCT_IF_C STT3135 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3135)");
    check_field_offset(lv, fa, 0, "STT3135.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3135, STT3135)
//============================================================================


struct  STT3145  {
  long fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT3145) C1{ Fl FL:48 Fp}



static void Test_STT3145()
{
  {
    init_simple_test("STT3145");
    static STRUCT_IF_C STT3145 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3145)");
    check_field_offset(lv, fa, 0, "STT3145.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3145, STT3145)
//============================================================================


struct  STT3155  {
  long fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT3155) C1{ Fl Fc:3 Fp}



static void Test_STT3155()
{
  {
    init_simple_test("STT3155");
    static STRUCT_IF_C STT3155 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3155)");
    check_field_offset(lv, fa, 0, "STT3155.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3155");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3155");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3155, STT3155)
//============================================================================


struct  STT3165  {
  long fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT3165) C1{ Fl Fs:3 Fp}



static void Test_STT3165()
{
  {
    init_simple_test("STT3165");
    static STRUCT_IF_C STT3165 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3165)");
    check_field_offset(lv, fa, 0, "STT3165.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3165");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3165");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3165, STT3165)
//============================================================================


struct  STT3175  {
  long fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT3175) C1{ Fl Fi:3 Fp}



static void Test_STT3175()
{
  {
    init_simple_test("STT3175");
    static STRUCT_IF_C STT3175 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3175)");
    check_field_offset(lv, fa, 0, "STT3175.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3175");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3175");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3175, STT3175)
//============================================================================


struct  STT3185  {
  long fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT3185) C1{ Fl FL:3 Fp}



static void Test_STT3185()
{
  {
    init_simple_test("STT3185");
    static STRUCT_IF_C STT3185 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3185)");
    check_field_offset(lv, fa, 0, "STT3185.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3185");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3185");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3185, STT3185)
//============================================================================


struct  STT3195  {
  long fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT3195) C1{ Fl Fs:8 Fp}



static void Test_STT3195()
{
  {
    init_simple_test("STT3195");
    static STRUCT_IF_C STT3195 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3195)");
    check_field_offset(lv, fa, 0, "STT3195.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3195");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3195");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3195, STT3195)
//============================================================================


struct  STT3205  {
  long fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT3205) C1{ Fl Fi:8 Fp}



static void Test_STT3205()
{
  {
    init_simple_test("STT3205");
    static STRUCT_IF_C STT3205 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3205)");
    check_field_offset(lv, fa, 0, "STT3205.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3205");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3205");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3205, STT3205)
//============================================================================


struct  STT3215  {
  long fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT3215) C1{ Fl FL:8 Fp}



static void Test_STT3215()
{
  {
    init_simple_test("STT3215");
    static STRUCT_IF_C STT3215 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3215)");
    check_field_offset(lv, fa, 0, "STT3215.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3215");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3215");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3215, STT3215)
//============================================================================


struct  STT3225  {
  long fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT3225) C1{ Fl Fi:18 Fp}



static void Test_STT3225()
{
  {
    init_simple_test("STT3225");
    static STRUCT_IF_C STT3225 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3225)");
    check_field_offset(lv, fa, 0, "STT3225.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3225");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3225");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3225, STT3225)
//============================================================================


struct  STT3235  {
  long fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT3235) C1{ Fl FL:18 Fp}



static void Test_STT3235()
{
  {
    init_simple_test("STT3235");
    static STRUCT_IF_C STT3235 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT3235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3235)");
    check_field_offset(lv, fa, 0, "STT3235.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3235");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3235");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3235, STT3235)
//============================================================================


struct  STT3245  {
  long fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT3245) C1{ Fl FL:48 Fp}



static void Test_STT3245()
{
  {
    init_simple_test("STT3245");
    static STRUCT_IF_C STT3245 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3245)");
    check_field_offset(lv, fa, 0, "STT3245.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3245");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3245");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3245, STT3245)
//============================================================================


struct  STT316  {
  long fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT316) C1{ Fl Fc:0 Fi}



static void Test_STT316()
{
  {
    init_simple_test("STT316");
    static STRUCT_IF_C STT316 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT316)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT316)");
    check_field_offset(lv, fa, 0, "STT316.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT316.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT316, STT316)
//============================================================================


struct  STT326  {
  long fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT326) C1{ Fl Fs:0 Fi}



static void Test_STT326()
{
  {
    init_simple_test("STT326");
    static STRUCT_IF_C STT326 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT326)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT326)");
    check_field_offset(lv, fa, 0, "STT326.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT326.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT326, STT326)
//============================================================================


struct  STT336  {
  long fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT336) C1{ Fl Fi:0 Fi}



static void Test_STT336()
{
  {
    init_simple_test("STT336");
    static STRUCT_IF_C STT336 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT336)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT336)");
    check_field_offset(lv, fa, 0, "STT336.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT336.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT336, STT336)
//============================================================================


struct  STT346  {
  long fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT346) C1{ Fl FL:0 Fi}



static void Test_STT346()
{
  {
    init_simple_test("STT346");
    static STRUCT_IF_C STT346 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT346)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT346)");
    check_field_offset(lv, fa, 0, "STT346.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT346.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT346, STT346)
//============================================================================


struct  STT356  {
  long fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT356) C1{ Fl Fc:3 Fi}



static void Test_STT356()
{
  {
    init_simple_test("STT356");
    static STRUCT_IF_C STT356 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT356)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT356)");
    check_field_offset(lv, fa, 0, "STT356.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT356.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT356, STT356)
//============================================================================


struct  STT366  {
  long fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT366) C1{ Fl Fs:3 Fi}



static void Test_STT366()
{
  {
    init_simple_test("STT366");
    static STRUCT_IF_C STT366 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT366)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT366)");
    check_field_offset(lv, fa, 0, "STT366.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT366.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT366, STT366)
//============================================================================


struct  STT376  {
  long fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT376) C1{ Fl Fi:3 Fi}



static void Test_STT376()
{
  {
    init_simple_test("STT376");
    static STRUCT_IF_C STT376 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT376)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT376)");
    check_field_offset(lv, fa, 0, "STT376.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT376.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT376, STT376)
//============================================================================


struct  STT386  {
  long fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT386) C1{ Fl FL:3 Fi}



static void Test_STT386()
{
  {
    init_simple_test("STT386");
    static STRUCT_IF_C STT386 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT386)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT386)");
    check_field_offset(lv, fa, 0, "STT386.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT386.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT386, STT386)
//============================================================================


struct  STT396  {
  long fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT396) C1{ Fl Fs:8 Fi}



static void Test_STT396()
{
  {
    init_simple_test("STT396");
    static STRUCT_IF_C STT396 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT396)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT396)");
    check_field_offset(lv, fa, 0, "STT396.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT396.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT396, STT396)
//============================================================================


struct  STT3106  {
  long fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT3106) C1{ Fl Fi:8 Fi}



static void Test_STT3106()
{
  {
    init_simple_test("STT3106");
    static STRUCT_IF_C STT3106 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3106)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3106)");
    check_field_offset(lv, fa, 0, "STT3106.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3106, STT3106)
//============================================================================


struct  STT3116  {
  long fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT3116) C1{ Fl FL:8 Fi}



static void Test_STT3116()
{
  {
    init_simple_test("STT3116");
    static STRUCT_IF_C STT3116 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3116)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3116)");
    check_field_offset(lv, fa, 0, "STT3116.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3116, STT3116)
//============================================================================


struct  STT3126  {
  long fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT3126) C1{ Fl Fi:18 Fi}



static void Test_STT3126()
{
  {
    init_simple_test("STT3126");
    static STRUCT_IF_C STT3126 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3126)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3126)");
    check_field_offset(lv, fa, 0, "STT3126.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3126, STT3126)
//============================================================================


struct  STT3136  {
  long fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT3136) C1{ Fl FL:18 Fi}



static void Test_STT3136()
{
  {
    init_simple_test("STT3136");
    static STRUCT_IF_C STT3136 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3136)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3136)");
    check_field_offset(lv, fa, 0, "STT3136.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3136, STT3136)
//============================================================================


struct  STT3146  {
  long fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT3146) C1{ Fl FL:48 Fi}



static void Test_STT3146()
{
  {
    init_simple_test("STT3146");
    static STRUCT_IF_C STT3146 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3146)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3146)");
    check_field_offset(lv, fa, 0, "STT3146.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3146, STT3146)
//============================================================================


struct  STT3156  {
  long fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT3156) C1{ Fl Fc:3 Fi}



static void Test_STT3156()
{
  {
    init_simple_test("STT3156");
    static STRUCT_IF_C STT3156 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3156)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3156)");
    check_field_offset(lv, fa, 0, "STT3156.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3156");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3156");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3156, STT3156)
//============================================================================


struct  STT3166  {
  long fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT3166) C1{ Fl Fs:3 Fi}



static void Test_STT3166()
{
  {
    init_simple_test("STT3166");
    static STRUCT_IF_C STT3166 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3166)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3166)");
    check_field_offset(lv, fa, 0, "STT3166.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3166");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3166");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3166, STT3166)
//============================================================================


struct  STT3176  {
  long fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT3176) C1{ Fl Fi:3 Fi}



static void Test_STT3176()
{
  {
    init_simple_test("STT3176");
    static STRUCT_IF_C STT3176 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3176)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3176)");
    check_field_offset(lv, fa, 0, "STT3176.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3176");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3176");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3176, STT3176)
//============================================================================


struct  STT3186  {
  long fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT3186) C1{ Fl FL:3 Fi}



static void Test_STT3186()
{
  {
    init_simple_test("STT3186");
    static STRUCT_IF_C STT3186 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3186)");
    check_field_offset(lv, fa, 0, "STT3186.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3186");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3186");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3186, STT3186)
//============================================================================


struct  STT3196  {
  long fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT3196) C1{ Fl Fs:8 Fi}



static void Test_STT3196()
{
  {
    init_simple_test("STT3196");
    static STRUCT_IF_C STT3196 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3196)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3196)");
    check_field_offset(lv, fa, 0, "STT3196.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3196");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3196");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3196, STT3196)
//============================================================================


struct  STT3206  {
  long fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT3206) C1{ Fl Fi:8 Fi}



static void Test_STT3206()
{
  {
    init_simple_test("STT3206");
    static STRUCT_IF_C STT3206 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3206)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3206)");
    check_field_offset(lv, fa, 0, "STT3206.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3206");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3206");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3206, STT3206)
//============================================================================


struct  STT3216  {
  long fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT3216) C1{ Fl FL:8 Fi}



static void Test_STT3216()
{
  {
    init_simple_test("STT3216");
    static STRUCT_IF_C STT3216 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3216)");
    check_field_offset(lv, fa, 0, "STT3216.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3216");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3216");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3216, STT3216)
//============================================================================


struct  STT3226  {
  long fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT3226) C1{ Fl Fi:18 Fi}



static void Test_STT3226()
{
  {
    init_simple_test("STT3226");
    static STRUCT_IF_C STT3226 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3226)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3226)");
    check_field_offset(lv, fa, 0, "STT3226.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3226");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3226");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3226, STT3226)
//============================================================================


struct  STT3236  {
  long fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT3236) C1{ Fl FL:18 Fi}



static void Test_STT3236()
{
  {
    init_simple_test("STT3236");
    static STRUCT_IF_C STT3236 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3236)");
    check_field_offset(lv, fa, 0, "STT3236.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3236");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3236");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT3236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3236, STT3236)
//============================================================================


struct  STT3246  {
  long fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT3246) C1{ Fl FL:48 Fi}



static void Test_STT3246()
{
  {
    init_simple_test("STT3246");
    static STRUCT_IF_C STT3246 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3246)");
    check_field_offset(lv, fa, 0, "STT3246.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3246");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3246");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3246, STT3246)
//============================================================================


struct  STT317  {
  long fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT317) C1{ Fl Fc:0 FL}



static void Test_STT317()
{
  {
    init_simple_test("STT317");
    static STRUCT_IF_C STT317 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT317)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT317)");
    check_field_offset(lv, fa, 0, "STT317.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT317.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT317, STT317)
//============================================================================


struct  STT327  {
  long fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT327) C1{ Fl Fs:0 FL}



static void Test_STT327()
{
  {
    init_simple_test("STT327");
    static STRUCT_IF_C STT327 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT327)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT327)");
    check_field_offset(lv, fa, 0, "STT327.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT327.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT327, STT327)
//============================================================================


struct  STT337  {
  long fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT337) C1{ Fl Fi:0 FL}



static void Test_STT337()
{
  {
    init_simple_test("STT337");
    static STRUCT_IF_C STT337 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT337)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT337)");
    check_field_offset(lv, fa, 0, "STT337.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT337.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT337, STT337)
//============================================================================


struct  STT347  {
  long fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT347) C1{ Fl FL:0 FL}



static void Test_STT347()
{
  {
    init_simple_test("STT347");
    static STRUCT_IF_C STT347 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT347)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT347)");
    check_field_offset(lv, fa, 0, "STT347.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT347.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT347, STT347)
//============================================================================


struct  STT357  {
  long fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT357) C1{ Fl Fc:3 FL}



static void Test_STT357()
{
  {
    init_simple_test("STT357");
    static STRUCT_IF_C STT357 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT357)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT357)");
    check_field_offset(lv, fa, 0, "STT357.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT357.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT357, STT357)
//============================================================================


struct  STT367  {
  long fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT367) C1{ Fl Fs:3 FL}



static void Test_STT367()
{
  {
    init_simple_test("STT367");
    static STRUCT_IF_C STT367 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT367)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT367)");
    check_field_offset(lv, fa, 0, "STT367.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT367.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT367, STT367)
//============================================================================


struct  STT377  {
  long fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT377) C1{ Fl Fi:3 FL}



static void Test_STT377()
{
  {
    init_simple_test("STT377");
    static STRUCT_IF_C STT377 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT377)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT377)");
    check_field_offset(lv, fa, 0, "STT377.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT377.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT377, STT377)
//============================================================================


struct  STT387  {
  long fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT387) C1{ Fl FL:3 FL}



static void Test_STT387()
{
  {
    init_simple_test("STT387");
    static STRUCT_IF_C STT387 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT387)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT387)");
    check_field_offset(lv, fa, 0, "STT387.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT387.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT387, STT387)
//============================================================================


struct  STT397  {
  long fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT397) C1{ Fl Fs:8 FL}



static void Test_STT397()
{
  {
    init_simple_test("STT397");
    static STRUCT_IF_C STT397 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT397)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT397)");
    check_field_offset(lv, fa, 0, "STT397.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT397.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT397, STT397)
//============================================================================


struct  STT3107  {
  long fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT3107) C1{ Fl Fi:8 FL}



static void Test_STT3107()
{
  {
    init_simple_test("STT3107");
    static STRUCT_IF_C STT3107 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3107)");
    check_field_offset(lv, fa, 0, "STT3107.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3107, STT3107)
//============================================================================


struct  STT3117  {
  long fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT3117) C1{ Fl FL:8 FL}



static void Test_STT3117()
{
  {
    init_simple_test("STT3117");
    static STRUCT_IF_C STT3117 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3117)");
    check_field_offset(lv, fa, 0, "STT3117.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3117, STT3117)
//============================================================================


struct  STT3127  {
  long fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT3127) C1{ Fl Fi:18 FL}



static void Test_STT3127()
{
  {
    init_simple_test("STT3127");
    static STRUCT_IF_C STT3127 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3127)");
    check_field_offset(lv, fa, 0, "STT3127.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3127, STT3127)
//============================================================================


struct  STT3137  {
  long fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT3137) C1{ Fl FL:18 FL}



static void Test_STT3137()
{
  {
    init_simple_test("STT3137");
    static STRUCT_IF_C STT3137 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3137)");
    check_field_offset(lv, fa, 0, "STT3137.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3137, STT3137)
//============================================================================


struct  STT3147  {
  long fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT3147) C1{ Fl FL:48 FL}



static void Test_STT3147()
{
  {
    init_simple_test("STT3147");
    static STRUCT_IF_C STT3147 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT3147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3147)");
    check_field_offset(lv, fa, 0, "STT3147.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3147, STT3147)
//============================================================================


struct  STT3157  {
  long fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT3157) C1{ Fl Fc:3 FL}



static void Test_STT3157()
{
  {
    init_simple_test("STT3157");
    static STRUCT_IF_C STT3157 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3157)");
    check_field_offset(lv, fa, 0, "STT3157.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3157");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3157");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3157, STT3157)
//============================================================================


struct  STT3167  {
  long fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT3167) C1{ Fl Fs:3 FL}



static void Test_STT3167()
{
  {
    init_simple_test("STT3167");
    static STRUCT_IF_C STT3167 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3167)");
    check_field_offset(lv, fa, 0, "STT3167.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3167");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3167");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3167, STT3167)
//============================================================================


struct  STT3177  {
  long fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT3177) C1{ Fl Fi:3 FL}



static void Test_STT3177()
{
  {
    init_simple_test("STT3177");
    static STRUCT_IF_C STT3177 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3177)");
    check_field_offset(lv, fa, 0, "STT3177.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3177");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3177");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3177, STT3177)
//============================================================================


struct  STT3187  {
  long fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT3187) C1{ Fl FL:3 FL}



static void Test_STT3187()
{
  {
    init_simple_test("STT3187");
    static STRUCT_IF_C STT3187 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3187)");
    check_field_offset(lv, fa, 0, "STT3187.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3187");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3187");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3187, STT3187)
//============================================================================


struct  STT3197  {
  long fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT3197) C1{ Fl Fs:8 FL}



static void Test_STT3197()
{
  {
    init_simple_test("STT3197");
    static STRUCT_IF_C STT3197 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3197)");
    check_field_offset(lv, fa, 0, "STT3197.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3197");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3197");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3197, STT3197)
//============================================================================


struct  STT3207  {
  long fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT3207) C1{ Fl Fi:8 FL}



static void Test_STT3207()
{
  {
    init_simple_test("STT3207");
    static STRUCT_IF_C STT3207 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3207)");
    check_field_offset(lv, fa, 0, "STT3207.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3207");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3207");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3207, STT3207)
//============================================================================


struct  STT3217  {
  long fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT3217) C1{ Fl FL:8 FL}



static void Test_STT3217()
{
  {
    init_simple_test("STT3217");
    static STRUCT_IF_C STT3217 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3217)");
    check_field_offset(lv, fa, 0, "STT3217.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3217");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3217");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3217, STT3217)
//============================================================================


struct  STT3227  {
  long fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT3227) C1{ Fl Fi:18 FL}



static void Test_STT3227()
{
  {
    init_simple_test("STT3227");
    static STRUCT_IF_C STT3227 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3227)");
    check_field_offset(lv, fa, 0, "STT3227.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3227");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3227");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3227, STT3227)
//============================================================================


struct  STT3237  {
  long fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT3237) C1{ Fl FL:18 FL}



static void Test_STT3237()
{
  {
    init_simple_test("STT3237");
    static STRUCT_IF_C STT3237 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT3237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3237)");
    check_field_offset(lv, fa, 0, "STT3237.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3237");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3237");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3237, STT3237)
//============================================================================


struct  STT3247  {
  long fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT3247) C1{ Fl FL:48 FL}



static void Test_STT3247()
{
  {
    init_simple_test("STT3247");
    static STRUCT_IF_C STT3247 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT3247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3247)");
    check_field_offset(lv, fa, 0, "STT3247.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3247");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3247");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3247, STT3247)
//============================================================================


struct  STT318  {
  long fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT318) C1{ Fl Fc:0 FD}



static void Test_STT318()
{
  {
    init_simple_test("STT318");
    static STRUCT_IF_C STT318 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT318)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT318)");
    check_field_offset(lv, fa, 0, "STT318.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT318.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT318, STT318)
//============================================================================


struct  STT328  {
  long fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT328) C1{ Fl Fs:0 FD}



static void Test_STT328()
{
  {
    init_simple_test("STT328");
    static STRUCT_IF_C STT328 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT328)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT328)");
    check_field_offset(lv, fa, 0, "STT328.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT328.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT328, STT328)
//============================================================================


struct  STT338  {
  long fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT338) C1{ Fl Fi:0 FD}



static void Test_STT338()
{
  {
    init_simple_test("STT338");
    static STRUCT_IF_C STT338 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT338)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT338)");
    check_field_offset(lv, fa, 0, "STT338.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT338.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT338, STT338)
//============================================================================


struct  STT348  {
  long fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT348) C1{ Fl FL:0 FD}



static void Test_STT348()
{
  {
    init_simple_test("STT348");
    static STRUCT_IF_C STT348 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT348)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT348)");
    check_field_offset(lv, fa, 0, "STT348.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT348.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT348, STT348)
//============================================================================


struct  STT358  {
  long fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT358) C1{ Fl Fc:3 FD}



static void Test_STT358()
{
  {
    init_simple_test("STT358");
    static STRUCT_IF_C STT358 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT358)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT358)");
    check_field_offset(lv, fa, 0, "STT358.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT358.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT358, STT358)
//============================================================================


struct  STT368  {
  long fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT368) C1{ Fl Fs:3 FD}



static void Test_STT368()
{
  {
    init_simple_test("STT368");
    static STRUCT_IF_C STT368 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT368)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT368)");
    check_field_offset(lv, fa, 0, "STT368.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT368.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT368, STT368)
//============================================================================


struct  STT378  {
  long fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT378) C1{ Fl Fi:3 FD}



static void Test_STT378()
{
  {
    init_simple_test("STT378");
    static STRUCT_IF_C STT378 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT378)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT378)");
    check_field_offset(lv, fa, 0, "STT378.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT378.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT378, STT378)
//============================================================================


struct  STT388  {
  long fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT388) C1{ Fl FL:3 FD}



static void Test_STT388()
{
  {
    init_simple_test("STT388");
    static STRUCT_IF_C STT388 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT388)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT388)");
    check_field_offset(lv, fa, 0, "STT388.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT388.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT388, STT388)
//============================================================================


struct  STT398  {
  long fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT398) C1{ Fl Fs:8 FD}



static void Test_STT398()
{
  {
    init_simple_test("STT398");
    static STRUCT_IF_C STT398 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT398)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT398)");
    check_field_offset(lv, fa, 0, "STT398.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT398.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT398, STT398)
//============================================================================


struct  STT3108  {
  long fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT3108) C1{ Fl Fi:8 FD}



static void Test_STT3108()
{
  {
    init_simple_test("STT3108");
    static STRUCT_IF_C STT3108 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3108)");
    check_field_offset(lv, fa, 0, "STT3108.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3108, STT3108)
//============================================================================


struct  STT3118  {
  long fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT3118) C1{ Fl FL:8 FD}



static void Test_STT3118()
{
  {
    init_simple_test("STT3118");
    static STRUCT_IF_C STT3118 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3118)");
    check_field_offset(lv, fa, 0, "STT3118.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3118, STT3118)
//============================================================================


struct  STT3128  {
  long fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT3128) C1{ Fl Fi:18 FD}



static void Test_STT3128()
{
  {
    init_simple_test("STT3128");
    static STRUCT_IF_C STT3128 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3128)");
    check_field_offset(lv, fa, 0, "STT3128.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3128, STT3128)
//============================================================================


struct  STT3138  {
  long fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT3138) C1{ Fl FL:18 FD}



static void Test_STT3138()
{
  {
    init_simple_test("STT3138");
    static STRUCT_IF_C STT3138 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3138)");
    check_field_offset(lv, fa, 0, "STT3138.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3138, STT3138)
//============================================================================


struct  STT3148  {
  long fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT3148) C1{ Fl FL:48 FD}



static void Test_STT3148()
{
  {
    init_simple_test("STT3148");
    static STRUCT_IF_C STT3148 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT3148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3148)");
    check_field_offset(lv, fa, 0, "STT3148.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3148, STT3148)
//============================================================================


struct  STT3158  {
  long fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT3158) C1{ Fl Fc:3 FD}



static void Test_STT3158()
{
  {
    init_simple_test("STT3158");
    static STRUCT_IF_C STT3158 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3158)");
    check_field_offset(lv, fa, 0, "STT3158.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3158");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3158");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3158, STT3158)
//============================================================================


struct  STT3168  {
  long fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT3168) C1{ Fl Fs:3 FD}



static void Test_STT3168()
{
  {
    init_simple_test("STT3168");
    static STRUCT_IF_C STT3168 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3168)");
    check_field_offset(lv, fa, 0, "STT3168.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3168");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3168");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3168, STT3168)
//============================================================================


struct  STT3178  {
  long fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT3178) C1{ Fl Fi:3 FD}



static void Test_STT3178()
{
  {
    init_simple_test("STT3178");
    static STRUCT_IF_C STT3178 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3178)");
    check_field_offset(lv, fa, 0, "STT3178.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3178");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3178");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3178, STT3178)
//============================================================================


struct  STT3188  {
  long fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT3188) C1{ Fl FL:3 FD}



static void Test_STT3188()
{
  {
    init_simple_test("STT3188");
    static STRUCT_IF_C STT3188 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3188)");
    check_field_offset(lv, fa, 0, "STT3188.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3188");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3188");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3188, STT3188)
//============================================================================


struct  STT3198  {
  long fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT3198) C1{ Fl Fs:8 FD}



static void Test_STT3198()
{
  {
    init_simple_test("STT3198");
    static STRUCT_IF_C STT3198 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3198)");
    check_field_offset(lv, fa, 0, "STT3198.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3198");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3198");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3198, STT3198)
//============================================================================


struct  STT3208  {
  long fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT3208) C1{ Fl Fi:8 FD}



static void Test_STT3208()
{
  {
    init_simple_test("STT3208");
    static STRUCT_IF_C STT3208 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3208)");
    check_field_offset(lv, fa, 0, "STT3208.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3208");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3208");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3208, STT3208)
//============================================================================


struct  STT3218  {
  long fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT3218) C1{ Fl FL:8 FD}



static void Test_STT3218()
{
  {
    init_simple_test("STT3218");
    static STRUCT_IF_C STT3218 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3218)");
    check_field_offset(lv, fa, 0, "STT3218.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3218");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3218");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3218, STT3218)
//============================================================================


struct  STT3228  {
  long fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT3228) C1{ Fl Fi:18 FD}



static void Test_STT3228()
{
  {
    init_simple_test("STT3228");
    static STRUCT_IF_C STT3228 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3228)");
    check_field_offset(lv, fa, 0, "STT3228.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3228");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3228");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3228, STT3228)
//============================================================================


struct  STT3238  {
  long fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT3238) C1{ Fl FL:18 FD}



static void Test_STT3238()
{
  {
    init_simple_test("STT3238");
    static STRUCT_IF_C STT3238 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT3238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3238)");
    check_field_offset(lv, fa, 0, "STT3238.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3238");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3238");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT3238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3238, STT3238)
//============================================================================


struct  STT3248  {
  long fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT3248) C1{ Fl FL:48 FD}



static void Test_STT3248()
{
  {
    init_simple_test("STT3248");
    static STRUCT_IF_C STT3248 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT3248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT3248)");
    check_field_offset(lv, fa, 0, "STT3248.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3248");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3248");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT3248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3248, STT3248)
//============================================================================


struct  STT319  {
  long fa;
  unsigned char  :0;
};
//SIG(1 STT319) C1{ Fl Fc:0}



static void Test_STT319()
{
  {
    init_simple_test("STT319");
    static STRUCT_IF_C STT319 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT319)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT319)");
    check_field_offset(lv, fa, 0, "STT319.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT319, STT319)
//============================================================================


struct  STT329  {
  long fa;
  unsigned short  :0;
};
//SIG(1 STT329) C1{ Fl Fs:0}



static void Test_STT329()
{
  {
    init_simple_test("STT329");
    static STRUCT_IF_C STT329 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT329)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT329)");
    check_field_offset(lv, fa, 0, "STT329.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT329, STT329)
//============================================================================


struct  STT339  {
  long fa;
  unsigned int  :0;
};
//SIG(1 STT339) C1{ Fl Fi:0}



static void Test_STT339()
{
  {
    init_simple_test("STT339");
    static STRUCT_IF_C STT339 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT339)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT339)");
    check_field_offset(lv, fa, 0, "STT339.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT339, STT339)
//============================================================================


struct  STT349  {
  long fa;
  __tsu64  :0;
};
//SIG(1 STT349) C1{ Fl FL:0}



static void Test_STT349()
{
  {
    init_simple_test("STT349");
    static STRUCT_IF_C STT349 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT349)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT349)");
    check_field_offset(lv, fa, 0, "STT349.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT349, STT349)
//============================================================================


struct  STT359  {
  long fa;
  unsigned char  :3;
};
//SIG(1 STT359) C1{ Fl Fc:3}



static void Test_STT359()
{
  {
    init_simple_test("STT359");
    static STRUCT_IF_C STT359 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT359)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT359)");
    check_field_offset(lv, fa, 0, "STT359.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT359, STT359)
//============================================================================


struct  STT369  {
  long fa;
  unsigned short  :3;
};
//SIG(1 STT369) C1{ Fl Fs:3}



static void Test_STT369()
{
  {
    init_simple_test("STT369");
    static STRUCT_IF_C STT369 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT369)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT369)");
    check_field_offset(lv, fa, 0, "STT369.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT369, STT369)
//============================================================================


struct  STT379  {
  long fa;
  unsigned int  :3;
};
//SIG(1 STT379) C1{ Fl Fi:3}



static void Test_STT379()
{
  {
    init_simple_test("STT379");
    static STRUCT_IF_C STT379 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT379)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT379)");
    check_field_offset(lv, fa, 0, "STT379.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT379, STT379)
//============================================================================


struct  STT389  {
  long fa;
  __tsu64  :3;
};
//SIG(1 STT389) C1{ Fl FL:3}



static void Test_STT389()
{
  {
    init_simple_test("STT389");
    static STRUCT_IF_C STT389 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT389)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT389)");
    check_field_offset(lv, fa, 0, "STT389.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT389, STT389)
//============================================================================


struct  STT399  {
  long fa;
  unsigned short  :8;
};
//SIG(1 STT399) C1{ Fl Fs:8}



static void Test_STT399()
{
  {
    init_simple_test("STT399");
    static STRUCT_IF_C STT399 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT399)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT399)");
    check_field_offset(lv, fa, 0, "STT399.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT399, STT399)
//============================================================================


struct  STT3109  {
  long fa;
  unsigned int  :8;
};
//SIG(1 STT3109) C1{ Fl Fi:8}



static void Test_STT3109()
{
  {
    init_simple_test("STT3109");
    static STRUCT_IF_C STT3109 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3109)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3109)");
    check_field_offset(lv, fa, 0, "STT3109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3109, STT3109)
//============================================================================


struct  STT3119  {
  long fa;
  __tsu64  :8;
};
//SIG(1 STT3119) C1{ Fl FL:8}



static void Test_STT3119()
{
  {
    init_simple_test("STT3119");
    static STRUCT_IF_C STT3119 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3119)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3119)");
    check_field_offset(lv, fa, 0, "STT3119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3119, STT3119)
//============================================================================


struct  STT3129  {
  long fa;
  unsigned int  :18;
};
//SIG(1 STT3129) C1{ Fl Fi:18}



static void Test_STT3129()
{
  {
    init_simple_test("STT3129");
    static STRUCT_IF_C STT3129 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3129)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3129)");
    check_field_offset(lv, fa, 0, "STT3129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3129, STT3129)
//============================================================================


struct  STT3139  {
  long fa;
  __tsu64  :18;
};
//SIG(1 STT3139) C1{ Fl FL:18}



static void Test_STT3139()
{
  {
    init_simple_test("STT3139");
    static STRUCT_IF_C STT3139 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3139)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3139)");
    check_field_offset(lv, fa, 0, "STT3139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3139, STT3139)
//============================================================================


struct  STT3149  {
  long fa;
  __tsu64  :48;
};
//SIG(1 STT3149) C1{ Fl FL:48}



static void Test_STT3149()
{
  {
    init_simple_test("STT3149");
    static STRUCT_IF_C STT3149 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3149)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3149)");
    check_field_offset(lv, fa, 0, "STT3149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3149, STT3149)
//============================================================================


struct  STT3159  {
  long fa;
  unsigned char bf:3;
};
//SIG(1 STT3159) C1{ Fl Fc:3}



static void Test_STT3159()
{
  {
    init_simple_test("STT3159");
    static STRUCT_IF_C STT3159 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3159)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3159)");
    check_field_offset(lv, fa, 0, "STT3159.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3159");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3159, STT3159)
//============================================================================


struct  STT3169  {
  long fa;
  unsigned short bf:3;
};
//SIG(1 STT3169) C1{ Fl Fs:3}



static void Test_STT3169()
{
  {
    init_simple_test("STT3169");
    static STRUCT_IF_C STT3169 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3169)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3169)");
    check_field_offset(lv, fa, 0, "STT3169.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3169");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3169, STT3169)
//============================================================================


struct  STT3179  {
  long fa;
  unsigned int bf:3;
};
//SIG(1 STT3179) C1{ Fl Fi:3}



static void Test_STT3179()
{
  {
    init_simple_test("STT3179");
    static STRUCT_IF_C STT3179 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3179)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3179)");
    check_field_offset(lv, fa, 0, "STT3179.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3179");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3179, STT3179)
//============================================================================


struct  STT3189  {
  long fa;
  __tsu64 bf:3;
};
//SIG(1 STT3189) C1{ Fl FL:3}



static void Test_STT3189()
{
  {
    init_simple_test("STT3189");
    static STRUCT_IF_C STT3189 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3189)");
    check_field_offset(lv, fa, 0, "STT3189.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT3189");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT3189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3189, STT3189)
//============================================================================


struct  STT3199  {
  long fa;
  unsigned short bf:8;
};
//SIG(1 STT3199) C1{ Fl Fs:8}



static void Test_STT3199()
{
  {
    init_simple_test("STT3199");
    static STRUCT_IF_C STT3199 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3199)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3199)");
    check_field_offset(lv, fa, 0, "STT3199.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3199");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3199, STT3199)
//============================================================================


struct  STT3209  {
  long fa;
  unsigned int bf:8;
};
//SIG(1 STT3209) C1{ Fl Fi:8}



static void Test_STT3209()
{
  {
    init_simple_test("STT3209");
    static STRUCT_IF_C STT3209 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3209)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3209)");
    check_field_offset(lv, fa, 0, "STT3209.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3209");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3209, STT3209)
//============================================================================


struct  STT3219  {
  long fa;
  __tsu64 bf:8;
};
//SIG(1 STT3219) C1{ Fl FL:8}



static void Test_STT3219()
{
  {
    init_simple_test("STT3219");
    static STRUCT_IF_C STT3219 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3219)");
    check_field_offset(lv, fa, 0, "STT3219.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT3219");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT3219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3219, STT3219)
//============================================================================


struct  STT3229  {
  long fa;
  unsigned int bf:18;
};
//SIG(1 STT3229) C1{ Fl Fi:18}



static void Test_STT3229()
{
  {
    init_simple_test("STT3229");
    static STRUCT_IF_C STT3229 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3229)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3229)");
    check_field_offset(lv, fa, 0, "STT3229.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3229");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3229, STT3229)
//============================================================================


struct  STT3239  {
  long fa;
  __tsu64 bf:18;
};
//SIG(1 STT3239) C1{ Fl FL:18}



static void Test_STT3239()
{
  {
    init_simple_test("STT3239");
    static STRUCT_IF_C STT3239 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT3239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3239)");
    check_field_offset(lv, fa, 0, "STT3239.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT3239");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT3239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3239, STT3239)
//============================================================================


struct  STT3249  {
  long fa;
  __tsu64 bf:48;
};
//SIG(1 STT3249) C1{ Fl FL:48}



static void Test_STT3249()
{
  {
    init_simple_test("STT3249");
    static STRUCT_IF_C STT3249 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT3249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT3249)");
    check_field_offset(lv, fa, 0, "STT3249.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT3249");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT3249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT3249, STT3249)
//============================================================================


struct  STT410  {
  __tsi64 fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT410) C1{ FL Fc:0 Fc}



static void Test_STT410()
{
  {
    init_simple_test("STT410");
    static STRUCT_IF_C STT410 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT410)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT410)");
    check_field_offset(lv, fa, 0, "STT410.fa");
    check_field_offset(lv, fb, 8, "STT410.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT410, STT410)
//============================================================================


struct  STT420  {
  __tsi64 fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT420) C1{ FL Fs:0 Fc}



static void Test_STT420()
{
  {
    init_simple_test("STT420");
    static STRUCT_IF_C STT420 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT420)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT420)");
    check_field_offset(lv, fa, 0, "STT420.fa");
    check_field_offset(lv, fb, 8, "STT420.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT420, STT420)
//============================================================================


struct  STT430  {
  __tsi64 fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT430) C1{ FL Fi:0 Fc}



static void Test_STT430()
{
  {
    init_simple_test("STT430");
    static STRUCT_IF_C STT430 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT430)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT430)");
    check_field_offset(lv, fa, 0, "STT430.fa");
    check_field_offset(lv, fb, 8, "STT430.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT430, STT430)
//============================================================================


struct  STT440  {
  __tsi64 fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT440) C1{ FL FL:0 Fc}



static void Test_STT440()
{
  {
    init_simple_test("STT440");
    static STRUCT_IF_C STT440 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT440)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT440)");
    check_field_offset(lv, fa, 0, "STT440.fa");
    check_field_offset(lv, fb, 8, "STT440.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT440, STT440)
//============================================================================


struct  STT450  {
  __tsi64 fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT450) C1{ FL Fc:3 Fc}



static void Test_STT450()
{
  {
    init_simple_test("STT450");
    static STRUCT_IF_C STT450 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT450)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT450)");
    check_field_offset(lv, fa, 0, "STT450.fa");
    check_field_offset(lv, fb, 9, "STT450.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT450, STT450)
//============================================================================


struct  STT460  {
  __tsi64 fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT460) C1{ FL Fs:3 Fc}



static void Test_STT460()
{
  {
    init_simple_test("STT460");
    static STRUCT_IF_C STT460 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT460)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT460)");
    check_field_offset(lv, fa, 0, "STT460.fa");
    check_field_offset(lv, fb, 9, "STT460.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT460, STT460)
//============================================================================


struct  STT470  {
  __tsi64 fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT470) C1{ FL Fi:3 Fc}



static void Test_STT470()
{
  {
    init_simple_test("STT470");
    static STRUCT_IF_C STT470 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT470)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT470)");
    check_field_offset(lv, fa, 0, "STT470.fa");
    check_field_offset(lv, fb, 9, "STT470.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT470, STT470)
//============================================================================


struct  STT480  {
  __tsi64 fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT480) C1{ FL FL:3 Fc}



static void Test_STT480()
{
  {
    init_simple_test("STT480");
    static STRUCT_IF_C STT480 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT480)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT480)");
    check_field_offset(lv, fa, 0, "STT480.fa");
    check_field_offset(lv, fb, 9, "STT480.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT480, STT480)
//============================================================================


struct  STT490  {
  __tsi64 fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT490) C1{ FL Fs:8 Fc}



static void Test_STT490()
{
  {
    init_simple_test("STT490");
    static STRUCT_IF_C STT490 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT490)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT490)");
    check_field_offset(lv, fa, 0, "STT490.fa");
    check_field_offset(lv, fb, 9, "STT490.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT490, STT490)
//============================================================================


struct  STT4100  {
  __tsi64 fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT4100) C1{ FL Fi:8 Fc}



static void Test_STT4100()
{
  {
    init_simple_test("STT4100");
    static STRUCT_IF_C STT4100 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4100)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4100)");
    check_field_offset(lv, fa, 0, "STT4100.fa");
    check_field_offset(lv, fb, 9, "STT4100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4100, STT4100)
//============================================================================


struct  STT4110  {
  __tsi64 fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT4110) C1{ FL FL:8 Fc}



static void Test_STT4110()
{
  {
    init_simple_test("STT4110");
    static STRUCT_IF_C STT4110 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4110)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4110)");
    check_field_offset(lv, fa, 0, "STT4110.fa");
    check_field_offset(lv, fb, 9, "STT4110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4110, STT4110)
//============================================================================


struct  STT4120  {
  __tsi64 fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT4120) C1{ FL Fi:18 Fc}



static void Test_STT4120()
{
  {
    init_simple_test("STT4120");
    static STRUCT_IF_C STT4120 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4120)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4120)");
    check_field_offset(lv, fa, 0, "STT4120.fa");
    check_field_offset(lv, fb, 11, "STT4120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4120, STT4120)
//============================================================================


struct  STT4130  {
  __tsi64 fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT4130) C1{ FL FL:18 Fc}



static void Test_STT4130()
{
  {
    init_simple_test("STT4130");
    static STRUCT_IF_C STT4130 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4130)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4130)");
    check_field_offset(lv, fa, 0, "STT4130.fa");
    check_field_offset(lv, fb, 11, "STT4130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4130, STT4130)
//============================================================================


struct  STT4140  {
  __tsi64 fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT4140) C1{ FL FL:48 Fc}



static void Test_STT4140()
{
  {
    init_simple_test("STT4140");
    static STRUCT_IF_C STT4140 lv;
    check2(sizeof(lv), 16, "sizeof(STT4140)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4140)");
    check_field_offset(lv, fa, 0, "STT4140.fa");
    check_field_offset(lv, fb, 14, "STT4140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4140, STT4140)
//============================================================================


struct  STT4150  {
  __tsi64 fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT4150) C1{ FL Fc:3 Fc}



static void Test_STT4150()
{
  {
    init_simple_test("STT4150");
    static STRUCT_IF_C STT4150 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4150)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4150)");
    check_field_offset(lv, fa, 0, "STT4150.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4150");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4150");
    check_field_offset(lv, fb, 9, "STT4150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4150, STT4150)
//============================================================================


struct  STT4160  {
  __tsi64 fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT4160) C1{ FL Fs:3 Fc}



static void Test_STT4160()
{
  {
    init_simple_test("STT4160");
    static STRUCT_IF_C STT4160 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4160)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4160)");
    check_field_offset(lv, fa, 0, "STT4160.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4160");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4160");
    check_field_offset(lv, fb, 9, "STT4160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4160, STT4160)
//============================================================================


struct  STT4170  {
  __tsi64 fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT4170) C1{ FL Fi:3 Fc}



static void Test_STT4170()
{
  {
    init_simple_test("STT4170");
    static STRUCT_IF_C STT4170 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4170)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4170)");
    check_field_offset(lv, fa, 0, "STT4170.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4170");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4170");
    check_field_offset(lv, fb, 9, "STT4170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4170, STT4170)
//============================================================================


struct  STT4180  {
  __tsi64 fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT4180) C1{ FL FL:3 Fc}



static void Test_STT4180()
{
  {
    init_simple_test("STT4180");
    static STRUCT_IF_C STT4180 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4180)");
    check_field_offset(lv, fa, 0, "STT4180.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4180");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4180");
    check_field_offset(lv, fb, 9, "STT4180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4180, STT4180)
//============================================================================


struct  STT4190  {
  __tsi64 fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT4190) C1{ FL Fs:8 Fc}



static void Test_STT4190()
{
  {
    init_simple_test("STT4190");
    static STRUCT_IF_C STT4190 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4190)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4190)");
    check_field_offset(lv, fa, 0, "STT4190.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4190");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4190");
    check_field_offset(lv, fb, 9, "STT4190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4190, STT4190)
//============================================================================


struct  STT4200  {
  __tsi64 fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT4200) C1{ FL Fi:8 Fc}



static void Test_STT4200()
{
  {
    init_simple_test("STT4200");
    static STRUCT_IF_C STT4200 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4200)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4200)");
    check_field_offset(lv, fa, 0, "STT4200.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4200");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4200");
    check_field_offset(lv, fb, 9, "STT4200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4200, STT4200)
//============================================================================


struct  STT4210  {
  __tsi64 fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT4210) C1{ FL FL:8 Fc}



static void Test_STT4210()
{
  {
    init_simple_test("STT4210");
    static STRUCT_IF_C STT4210 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4210)");
    check_field_offset(lv, fa, 0, "STT4210.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4210");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4210");
    check_field_offset(lv, fb, 9, "STT4210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4210, STT4210)
//============================================================================


struct  STT4220  {
  __tsi64 fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT4220) C1{ FL Fi:18 Fc}



static void Test_STT4220()
{
  {
    init_simple_test("STT4220");
    static STRUCT_IF_C STT4220 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4220)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4220)");
    check_field_offset(lv, fa, 0, "STT4220.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4220");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4220");
    check_field_offset(lv, fb, 11, "STT4220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4220, STT4220)
//============================================================================


struct  STT4230  {
  __tsi64 fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT4230) C1{ FL FL:18 Fc}



static void Test_STT4230()
{
  {
    init_simple_test("STT4230");
    static STRUCT_IF_C STT4230 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4230)");
    check_field_offset(lv, fa, 0, "STT4230.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4230");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4230");
    check_field_offset(lv, fb, 11, "STT4230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4230, STT4230)
//============================================================================


struct  STT4240  {
  __tsi64 fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT4240) C1{ FL FL:48 Fc}



static void Test_STT4240()
{
  {
    init_simple_test("STT4240");
    static STRUCT_IF_C STT4240 lv;
    check2(sizeof(lv), 16, "sizeof(STT4240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4240)");
    check_field_offset(lv, fa, 0, "STT4240.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4240");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4240");
    check_field_offset(lv, fb, 14, "STT4240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4240, STT4240)
//============================================================================


struct  STT411  {
  __tsi64 fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT411) C1{ FL Fc:0 Fs}



static void Test_STT411()
{
  {
    init_simple_test("STT411");
    static STRUCT_IF_C STT411 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT411)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT411)");
    check_field_offset(lv, fa, 0, "STT411.fa");
    check_field_offset(lv, fb, 8, "STT411.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT411, STT411)
//============================================================================


struct  STT421  {
  __tsi64 fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT421) C1{ FL Fs:0 Fs}



static void Test_STT421()
{
  {
    init_simple_test("STT421");
    static STRUCT_IF_C STT421 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT421)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT421)");
    check_field_offset(lv, fa, 0, "STT421.fa");
    check_field_offset(lv, fb, 8, "STT421.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT421, STT421)
//============================================================================


struct  STT431  {
  __tsi64 fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT431) C1{ FL Fi:0 Fs}



static void Test_STT431()
{
  {
    init_simple_test("STT431");
    static STRUCT_IF_C STT431 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT431)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT431)");
    check_field_offset(lv, fa, 0, "STT431.fa");
    check_field_offset(lv, fb, 8, "STT431.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT431, STT431)
//============================================================================


struct  STT441  {
  __tsi64 fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT441) C1{ FL FL:0 Fs}



static void Test_STT441()
{
  {
    init_simple_test("STT441");
    static STRUCT_IF_C STT441 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT441)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT441)");
    check_field_offset(lv, fa, 0, "STT441.fa");
    check_field_offset(lv, fb, 8, "STT441.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT441, STT441)
//============================================================================


struct  STT451  {
  __tsi64 fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT451) C1{ FL Fc:3 Fs}



static void Test_STT451()
{
  {
    init_simple_test("STT451");
    static STRUCT_IF_C STT451 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT451)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT451)");
    check_field_offset(lv, fa, 0, "STT451.fa");
    check_field_offset(lv, fb, 10, "STT451.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT451, STT451)
//============================================================================


struct  STT461  {
  __tsi64 fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT461) C1{ FL Fs:3 Fs}



static void Test_STT461()
{
  {
    init_simple_test("STT461");
    static STRUCT_IF_C STT461 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT461)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT461)");
    check_field_offset(lv, fa, 0, "STT461.fa");
    check_field_offset(lv, fb, 10, "STT461.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT461, STT461)
//============================================================================


struct  STT471  {
  __tsi64 fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT471) C1{ FL Fi:3 Fs}



static void Test_STT471()
{
  {
    init_simple_test("STT471");
    static STRUCT_IF_C STT471 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT471)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT471)");
    check_field_offset(lv, fa, 0, "STT471.fa");
    check_field_offset(lv, fb, 10, "STT471.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT471, STT471)
//============================================================================


struct  STT481  {
  __tsi64 fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT481) C1{ FL FL:3 Fs}



static void Test_STT481()
{
  {
    init_simple_test("STT481");
    static STRUCT_IF_C STT481 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT481)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT481)");
    check_field_offset(lv, fa, 0, "STT481.fa");
    check_field_offset(lv, fb, 10, "STT481.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT481, STT481)
//============================================================================


struct  STT491  {
  __tsi64 fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT491) C1{ FL Fs:8 Fs}



static void Test_STT491()
{
  {
    init_simple_test("STT491");
    static STRUCT_IF_C STT491 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT491)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT491)");
    check_field_offset(lv, fa, 0, "STT491.fa");
    check_field_offset(lv, fb, 10, "STT491.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT491, STT491)
//============================================================================


struct  STT4101  {
  __tsi64 fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT4101) C1{ FL Fi:8 Fs}



static void Test_STT4101()
{
  {
    init_simple_test("STT4101");
    static STRUCT_IF_C STT4101 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4101)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4101)");
    check_field_offset(lv, fa, 0, "STT4101.fa");
    check_field_offset(lv, fb, 10, "STT4101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4101, STT4101)
//============================================================================


struct  STT4111  {
  __tsi64 fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT4111) C1{ FL FL:8 Fs}



static void Test_STT4111()
{
  {
    init_simple_test("STT4111");
    static STRUCT_IF_C STT4111 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4111)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4111)");
    check_field_offset(lv, fa, 0, "STT4111.fa");
    check_field_offset(lv, fb, 10, "STT4111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4111, STT4111)
//============================================================================


struct  STT4121  {
  __tsi64 fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT4121) C1{ FL Fi:18 Fs}



static void Test_STT4121()
{
  {
    init_simple_test("STT4121");
    static STRUCT_IF_C STT4121 lv;
    check2(sizeof(lv), 16, "sizeof(STT4121)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4121)");
    check_field_offset(lv, fa, 0, "STT4121.fa");
    check_field_offset(lv, fb, 12, "STT4121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4121, STT4121)
//============================================================================


struct  STT4131  {
  __tsi64 fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT4131) C1{ FL FL:18 Fs}



static void Test_STT4131()
{
  {
    init_simple_test("STT4131");
    static STRUCT_IF_C STT4131 lv;
    check2(sizeof(lv), 16, "sizeof(STT4131)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4131)");
    check_field_offset(lv, fa, 0, "STT4131.fa");
    check_field_offset(lv, fb, 12, "STT4131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4131, STT4131)
//============================================================================


struct  STT4141  {
  __tsi64 fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT4141) C1{ FL FL:48 Fs}



static void Test_STT4141()
{
  {
    init_simple_test("STT4141");
    static STRUCT_IF_C STT4141 lv;
    check2(sizeof(lv), 16, "sizeof(STT4141)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4141)");
    check_field_offset(lv, fa, 0, "STT4141.fa");
    check_field_offset(lv, fb, 14, "STT4141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4141, STT4141)
//============================================================================


struct  STT4151  {
  __tsi64 fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT4151) C1{ FL Fc:3 Fs}



static void Test_STT4151()
{
  {
    init_simple_test("STT4151");
    static STRUCT_IF_C STT4151 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4151)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4151)");
    check_field_offset(lv, fa, 0, "STT4151.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4151");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4151");
    check_field_offset(lv, fb, 10, "STT4151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4151, STT4151)
//============================================================================


struct  STT4161  {
  __tsi64 fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT4161) C1{ FL Fs:3 Fs}



static void Test_STT4161()
{
  {
    init_simple_test("STT4161");
    static STRUCT_IF_C STT4161 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4161)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4161)");
    check_field_offset(lv, fa, 0, "STT4161.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4161");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4161");
    check_field_offset(lv, fb, 10, "STT4161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4161, STT4161)
//============================================================================


struct  STT4171  {
  __tsi64 fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT4171) C1{ FL Fi:3 Fs}



static void Test_STT4171()
{
  {
    init_simple_test("STT4171");
    static STRUCT_IF_C STT4171 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4171)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4171)");
    check_field_offset(lv, fa, 0, "STT4171.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4171");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4171");
    check_field_offset(lv, fb, 10, "STT4171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4171, STT4171)
//============================================================================


struct  STT4181  {
  __tsi64 fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT4181) C1{ FL FL:3 Fs}



static void Test_STT4181()
{
  {
    init_simple_test("STT4181");
    static STRUCT_IF_C STT4181 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4181)");
    check_field_offset(lv, fa, 0, "STT4181.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4181");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4181");
    check_field_offset(lv, fb, 10, "STT4181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4181, STT4181)
//============================================================================


struct  STT4191  {
  __tsi64 fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT4191) C1{ FL Fs:8 Fs}



static void Test_STT4191()
{
  {
    init_simple_test("STT4191");
    static STRUCT_IF_C STT4191 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4191)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4191)");
    check_field_offset(lv, fa, 0, "STT4191.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4191");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4191");
    check_field_offset(lv, fb, 10, "STT4191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4191, STT4191)
//============================================================================


struct  STT4201  {
  __tsi64 fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT4201) C1{ FL Fi:8 Fs}



static void Test_STT4201()
{
  {
    init_simple_test("STT4201");
    static STRUCT_IF_C STT4201 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4201)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4201)");
    check_field_offset(lv, fa, 0, "STT4201.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4201");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4201");
    check_field_offset(lv, fb, 10, "STT4201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4201, STT4201)
//============================================================================


struct  STT4211  {
  __tsi64 fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT4211) C1{ FL FL:8 Fs}



static void Test_STT4211()
{
  {
    init_simple_test("STT4211");
    static STRUCT_IF_C STT4211 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4211)");
    check_field_offset(lv, fa, 0, "STT4211.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4211");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4211");
    check_field_offset(lv, fb, 10, "STT4211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4211, STT4211)
//============================================================================


struct  STT4221  {
  __tsi64 fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT4221) C1{ FL Fi:18 Fs}



static void Test_STT4221()
{
  {
    init_simple_test("STT4221");
    static STRUCT_IF_C STT4221 lv;
    check2(sizeof(lv), 16, "sizeof(STT4221)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4221)");
    check_field_offset(lv, fa, 0, "STT4221.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4221");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4221");
    check_field_offset(lv, fb, 12, "STT4221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4221, STT4221)
//============================================================================


struct  STT4231  {
  __tsi64 fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT4231) C1{ FL FL:18 Fs}



static void Test_STT4231()
{
  {
    init_simple_test("STT4231");
    static STRUCT_IF_C STT4231 lv;
    check2(sizeof(lv), 16, "sizeof(STT4231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4231)");
    check_field_offset(lv, fa, 0, "STT4231.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4231");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4231");
    check_field_offset(lv, fb, 12, "STT4231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4231, STT4231)
//============================================================================


struct  STT4241  {
  __tsi64 fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT4241) C1{ FL FL:48 Fs}



static void Test_STT4241()
{
  {
    init_simple_test("STT4241");
    static STRUCT_IF_C STT4241 lv;
    check2(sizeof(lv), 16, "sizeof(STT4241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4241)");
    check_field_offset(lv, fa, 0, "STT4241.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4241");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4241");
    check_field_offset(lv, fb, 14, "STT4241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4241, STT4241)
//============================================================================


struct  STT412  {
  __tsi64 fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT412) C1{ FL Fc:0 Fi}



static void Test_STT412()
{
  {
    init_simple_test("STT412");
    static STRUCT_IF_C STT412 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT412)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT412)");
    check_field_offset(lv, fa, 0, "STT412.fa");
    check_field_offset(lv, fb, 8, "STT412.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT412, STT412)
//============================================================================


struct  STT422  {
  __tsi64 fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT422) C1{ FL Fs:0 Fi}



static void Test_STT422()
{
  {
    init_simple_test("STT422");
    static STRUCT_IF_C STT422 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT422)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT422)");
    check_field_offset(lv, fa, 0, "STT422.fa");
    check_field_offset(lv, fb, 8, "STT422.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT422, STT422)
//============================================================================


struct  STT432  {
  __tsi64 fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT432) C1{ FL Fi:0 Fi}



static void Test_STT432()
{
  {
    init_simple_test("STT432");
    static STRUCT_IF_C STT432 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT432)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT432)");
    check_field_offset(lv, fa, 0, "STT432.fa");
    check_field_offset(lv, fb, 8, "STT432.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT432, STT432)
//============================================================================


struct  STT442  {
  __tsi64 fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT442) C1{ FL FL:0 Fi}



static void Test_STT442()
{
  {
    init_simple_test("STT442");
    static STRUCT_IF_C STT442 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT442)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT442)");
    check_field_offset(lv, fa, 0, "STT442.fa");
    check_field_offset(lv, fb, 8, "STT442.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT442, STT442)
//============================================================================


struct  STT452  {
  __tsi64 fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT452) C1{ FL Fc:3 Fi}



static void Test_STT452()
{
  {
    init_simple_test("STT452");
    static STRUCT_IF_C STT452 lv;
    check2(sizeof(lv), 16, "sizeof(STT452)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT452)");
    check_field_offset(lv, fa, 0, "STT452.fa");
    check_field_offset(lv, fb, 12, "STT452.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT452, STT452)
//============================================================================


struct  STT462  {
  __tsi64 fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT462) C1{ FL Fs:3 Fi}



static void Test_STT462()
{
  {
    init_simple_test("STT462");
    static STRUCT_IF_C STT462 lv;
    check2(sizeof(lv), 16, "sizeof(STT462)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT462)");
    check_field_offset(lv, fa, 0, "STT462.fa");
    check_field_offset(lv, fb, 12, "STT462.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT462, STT462)
//============================================================================


struct  STT472  {
  __tsi64 fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT472) C1{ FL Fi:3 Fi}



static void Test_STT472()
{
  {
    init_simple_test("STT472");
    static STRUCT_IF_C STT472 lv;
    check2(sizeof(lv), 16, "sizeof(STT472)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT472)");
    check_field_offset(lv, fa, 0, "STT472.fa");
    check_field_offset(lv, fb, 12, "STT472.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT472, STT472)
//============================================================================


struct  STT482  {
  __tsi64 fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT482) C1{ FL FL:3 Fi}



static void Test_STT482()
{
  {
    init_simple_test("STT482");
    static STRUCT_IF_C STT482 lv;
    check2(sizeof(lv), 16, "sizeof(STT482)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT482)");
    check_field_offset(lv, fa, 0, "STT482.fa");
    check_field_offset(lv, fb, 12, "STT482.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT482, STT482)
//============================================================================


struct  STT492  {
  __tsi64 fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT492) C1{ FL Fs:8 Fi}



static void Test_STT492()
{
  {
    init_simple_test("STT492");
    static STRUCT_IF_C STT492 lv;
    check2(sizeof(lv), 16, "sizeof(STT492)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT492)");
    check_field_offset(lv, fa, 0, "STT492.fa");
    check_field_offset(lv, fb, 12, "STT492.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT492, STT492)
//============================================================================


struct  STT4102  {
  __tsi64 fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT4102) C1{ FL Fi:8 Fi}



static void Test_STT4102()
{
  {
    init_simple_test("STT4102");
    static STRUCT_IF_C STT4102 lv;
    check2(sizeof(lv), 16, "sizeof(STT4102)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4102)");
    check_field_offset(lv, fa, 0, "STT4102.fa");
    check_field_offset(lv, fb, 12, "STT4102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4102, STT4102)
//============================================================================


struct  STT4112  {
  __tsi64 fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT4112) C1{ FL FL:8 Fi}



static void Test_STT4112()
{
  {
    init_simple_test("STT4112");
    static STRUCT_IF_C STT4112 lv;
    check2(sizeof(lv), 16, "sizeof(STT4112)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4112)");
    check_field_offset(lv, fa, 0, "STT4112.fa");
    check_field_offset(lv, fb, 12, "STT4112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4112, STT4112)
//============================================================================


struct  STT4122  {
  __tsi64 fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT4122) C1{ FL Fi:18 Fi}



static void Test_STT4122()
{
  {
    init_simple_test("STT4122");
    static STRUCT_IF_C STT4122 lv;
    check2(sizeof(lv), 16, "sizeof(STT4122)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4122)");
    check_field_offset(lv, fa, 0, "STT4122.fa");
    check_field_offset(lv, fb, 12, "STT4122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4122, STT4122)
//============================================================================


struct  STT4132  {
  __tsi64 fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT4132) C1{ FL FL:18 Fi}



static void Test_STT4132()
{
  {
    init_simple_test("STT4132");
    static STRUCT_IF_C STT4132 lv;
    check2(sizeof(lv), 16, "sizeof(STT4132)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4132)");
    check_field_offset(lv, fa, 0, "STT4132.fa");
    check_field_offset(lv, fb, 12, "STT4132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4132, STT4132)
//============================================================================


struct  STT4142  {
  __tsi64 fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT4142) C1{ FL FL:48 Fi}



static void Test_STT4142()
{
  {
    init_simple_test("STT4142");
    static STRUCT_IF_C STT4142 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4142)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4142)");
    check_field_offset(lv, fa, 0, "STT4142.fa");
    check_field_offset(lv, fb, 16, "STT4142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4142, STT4142)
//============================================================================


struct  STT4152  {
  __tsi64 fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT4152) C1{ FL Fc:3 Fi}



static void Test_STT4152()
{
  {
    init_simple_test("STT4152");
    static STRUCT_IF_C STT4152 lv;
    check2(sizeof(lv), 16, "sizeof(STT4152)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4152)");
    check_field_offset(lv, fa, 0, "STT4152.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4152");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4152");
    check_field_offset(lv, fb, 12, "STT4152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4152, STT4152)
//============================================================================


struct  STT4162  {
  __tsi64 fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT4162) C1{ FL Fs:3 Fi}



static void Test_STT4162()
{
  {
    init_simple_test("STT4162");
    static STRUCT_IF_C STT4162 lv;
    check2(sizeof(lv), 16, "sizeof(STT4162)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4162)");
    check_field_offset(lv, fa, 0, "STT4162.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4162");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4162");
    check_field_offset(lv, fb, 12, "STT4162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4162, STT4162)
//============================================================================


struct  STT4172  {
  __tsi64 fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT4172) C1{ FL Fi:3 Fi}



static void Test_STT4172()
{
  {
    init_simple_test("STT4172");
    static STRUCT_IF_C STT4172 lv;
    check2(sizeof(lv), 16, "sizeof(STT4172)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4172)");
    check_field_offset(lv, fa, 0, "STT4172.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4172");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4172");
    check_field_offset(lv, fb, 12, "STT4172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4172, STT4172)
//============================================================================


struct  STT4182  {
  __tsi64 fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT4182) C1{ FL FL:3 Fi}



static void Test_STT4182()
{
  {
    init_simple_test("STT4182");
    static STRUCT_IF_C STT4182 lv;
    check2(sizeof(lv), 16, "sizeof(STT4182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4182)");
    check_field_offset(lv, fa, 0, "STT4182.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4182");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4182");
    check_field_offset(lv, fb, 12, "STT4182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4182, STT4182)
//============================================================================


struct  STT4192  {
  __tsi64 fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT4192) C1{ FL Fs:8 Fi}



static void Test_STT4192()
{
  {
    init_simple_test("STT4192");
    static STRUCT_IF_C STT4192 lv;
    check2(sizeof(lv), 16, "sizeof(STT4192)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4192)");
    check_field_offset(lv, fa, 0, "STT4192.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4192");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4192");
    check_field_offset(lv, fb, 12, "STT4192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4192, STT4192)
//============================================================================


struct  STT4202  {
  __tsi64 fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT4202) C1{ FL Fi:8 Fi}



static void Test_STT4202()
{
  {
    init_simple_test("STT4202");
    static STRUCT_IF_C STT4202 lv;
    check2(sizeof(lv), 16, "sizeof(STT4202)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4202)");
    check_field_offset(lv, fa, 0, "STT4202.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4202");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4202");
    check_field_offset(lv, fb, 12, "STT4202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4202, STT4202)
//============================================================================


struct  STT4212  {
  __tsi64 fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT4212) C1{ FL FL:8 Fi}



static void Test_STT4212()
{
  {
    init_simple_test("STT4212");
    static STRUCT_IF_C STT4212 lv;
    check2(sizeof(lv), 16, "sizeof(STT4212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4212)");
    check_field_offset(lv, fa, 0, "STT4212.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4212");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4212");
    check_field_offset(lv, fb, 12, "STT4212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4212, STT4212)
//============================================================================


struct  STT4222  {
  __tsi64 fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT4222) C1{ FL Fi:18 Fi}



static void Test_STT4222()
{
  {
    init_simple_test("STT4222");
    static STRUCT_IF_C STT4222 lv;
    check2(sizeof(lv), 16, "sizeof(STT4222)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4222)");
    check_field_offset(lv, fa, 0, "STT4222.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4222");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4222");
    check_field_offset(lv, fb, 12, "STT4222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4222, STT4222)
//============================================================================


struct  STT4232  {
  __tsi64 fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT4232) C1{ FL FL:18 Fi}



static void Test_STT4232()
{
  {
    init_simple_test("STT4232");
    static STRUCT_IF_C STT4232 lv;
    check2(sizeof(lv), 16, "sizeof(STT4232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4232)");
    check_field_offset(lv, fa, 0, "STT4232.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4232");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4232");
    check_field_offset(lv, fb, 12, "STT4232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4232, STT4232)
//============================================================================


struct  STT4242  {
  __tsi64 fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT4242) C1{ FL FL:48 Fi}



static void Test_STT4242()
{
  {
    init_simple_test("STT4242");
    static STRUCT_IF_C STT4242 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4242)");
    check_field_offset(lv, fa, 0, "STT4242.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4242");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4242");
    check_field_offset(lv, fb, 16, "STT4242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4242, STT4242)
//============================================================================


struct  STT413  {
  __tsi64 fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT413) C1{ FL Fc:0 Fl}



static void Test_STT413()
{
  {
    init_simple_test("STT413");
    static STRUCT_IF_C STT413 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT413)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT413)");
    check_field_offset(lv, fa, 0, "STT413.fa");
    check_field_offset(lv, fb, 8, "STT413.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT413, STT413)
//============================================================================


struct  STT423  {
  __tsi64 fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT423) C1{ FL Fs:0 Fl}



static void Test_STT423()
{
  {
    init_simple_test("STT423");
    static STRUCT_IF_C STT423 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT423)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT423)");
    check_field_offset(lv, fa, 0, "STT423.fa");
    check_field_offset(lv, fb, 8, "STT423.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT423, STT423)
//============================================================================


struct  STT433  {
  __tsi64 fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT433) C1{ FL Fi:0 Fl}



static void Test_STT433()
{
  {
    init_simple_test("STT433");
    static STRUCT_IF_C STT433 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT433)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT433)");
    check_field_offset(lv, fa, 0, "STT433.fa");
    check_field_offset(lv, fb, 8, "STT433.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT433, STT433)
//============================================================================


struct  STT443  {
  __tsi64 fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT443) C1{ FL FL:0 Fl}



static void Test_STT443()
{
  {
    init_simple_test("STT443");
    static STRUCT_IF_C STT443 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT443)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT443)");
    check_field_offset(lv, fa, 0, "STT443.fa");
    check_field_offset(lv, fb, 8, "STT443.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT443, STT443)
//============================================================================


struct  STT453  {
  __tsi64 fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT453) C1{ FL Fc:3 Fl}



static void Test_STT453()
{
  {
    init_simple_test("STT453");
    static STRUCT_IF_C STT453 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT453)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT453)");
    check_field_offset(lv, fa, 0, "STT453.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT453.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT453, STT453)
//============================================================================


struct  STT463  {
  __tsi64 fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT463) C1{ FL Fs:3 Fl}



static void Test_STT463()
{
  {
    init_simple_test("STT463");
    static STRUCT_IF_C STT463 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT463)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT463)");
    check_field_offset(lv, fa, 0, "STT463.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT463.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT463, STT463)
//============================================================================


struct  STT473  {
  __tsi64 fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT473) C1{ FL Fi:3 Fl}



static void Test_STT473()
{
  {
    init_simple_test("STT473");
    static STRUCT_IF_C STT473 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT473)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT473)");
    check_field_offset(lv, fa, 0, "STT473.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT473.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT473, STT473)
//============================================================================


struct  STT483  {
  __tsi64 fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT483) C1{ FL FL:3 Fl}



static void Test_STT483()
{
  {
    init_simple_test("STT483");
    static STRUCT_IF_C STT483 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT483)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT483)");
    check_field_offset(lv, fa, 0, "STT483.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT483.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT483, STT483)
//============================================================================


struct  STT493  {
  __tsi64 fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT493) C1{ FL Fs:8 Fl}



static void Test_STT493()
{
  {
    init_simple_test("STT493");
    static STRUCT_IF_C STT493 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT493)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT493)");
    check_field_offset(lv, fa, 0, "STT493.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT493.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT493, STT493)
//============================================================================


struct  STT4103  {
  __tsi64 fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT4103) C1{ FL Fi:8 Fl}



static void Test_STT4103()
{
  {
    init_simple_test("STT4103");
    static STRUCT_IF_C STT4103 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4103)");
    check_field_offset(lv, fa, 0, "STT4103.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4103, STT4103)
//============================================================================


struct  STT4113  {
  __tsi64 fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT4113) C1{ FL FL:8 Fl}



static void Test_STT4113()
{
  {
    init_simple_test("STT4113");
    static STRUCT_IF_C STT4113 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4113)");
    check_field_offset(lv, fa, 0, "STT4113.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4113, STT4113)
//============================================================================


struct  STT4123  {
  __tsi64 fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT4123) C1{ FL Fi:18 Fl}



static void Test_STT4123()
{
  {
    init_simple_test("STT4123");
    static STRUCT_IF_C STT4123 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4123)");
    check_field_offset(lv, fa, 0, "STT4123.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4123, STT4123)
//============================================================================


struct  STT4133  {
  __tsi64 fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT4133) C1{ FL FL:18 Fl}



static void Test_STT4133()
{
  {
    init_simple_test("STT4133");
    static STRUCT_IF_C STT4133 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4133)");
    check_field_offset(lv, fa, 0, "STT4133.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4133, STT4133)
//============================================================================


struct  STT4143  {
  __tsi64 fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT4143) C1{ FL FL:48 Fl}



static void Test_STT4143()
{
  {
    init_simple_test("STT4143");
    static STRUCT_IF_C STT4143 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4143)");
    check_field_offset(lv, fa, 0, "STT4143.fa");
    check_field_offset(lv, fb, 16, "STT4143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4143, STT4143)
//============================================================================


struct  STT4153  {
  __tsi64 fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT4153) C1{ FL Fc:3 Fl}



static void Test_STT4153()
{
  {
    init_simple_test("STT4153");
    static STRUCT_IF_C STT4153 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4153)");
    check_field_offset(lv, fa, 0, "STT4153.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4153");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4153");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4153, STT4153)
//============================================================================


struct  STT4163  {
  __tsi64 fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT4163) C1{ FL Fs:3 Fl}



static void Test_STT4163()
{
  {
    init_simple_test("STT4163");
    static STRUCT_IF_C STT4163 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4163)");
    check_field_offset(lv, fa, 0, "STT4163.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4163");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4163");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4163, STT4163)
//============================================================================


struct  STT4173  {
  __tsi64 fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT4173) C1{ FL Fi:3 Fl}



static void Test_STT4173()
{
  {
    init_simple_test("STT4173");
    static STRUCT_IF_C STT4173 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4173)");
    check_field_offset(lv, fa, 0, "STT4173.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4173");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4173");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4173, STT4173)
//============================================================================


struct  STT4183  {
  __tsi64 fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT4183) C1{ FL FL:3 Fl}



static void Test_STT4183()
{
  {
    init_simple_test("STT4183");
    static STRUCT_IF_C STT4183 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4183)");
    check_field_offset(lv, fa, 0, "STT4183.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4183");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4183");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4183, STT4183)
//============================================================================


struct  STT4193  {
  __tsi64 fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT4193) C1{ FL Fs:8 Fl}



static void Test_STT4193()
{
  {
    init_simple_test("STT4193");
    static STRUCT_IF_C STT4193 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4193)");
    check_field_offset(lv, fa, 0, "STT4193.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4193");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4193");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4193, STT4193)
//============================================================================


struct  STT4203  {
  __tsi64 fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT4203) C1{ FL Fi:8 Fl}



static void Test_STT4203()
{
  {
    init_simple_test("STT4203");
    static STRUCT_IF_C STT4203 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4203)");
    check_field_offset(lv, fa, 0, "STT4203.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4203");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4203");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4203, STT4203)
//============================================================================


struct  STT4213  {
  __tsi64 fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT4213) C1{ FL FL:8 Fl}



static void Test_STT4213()
{
  {
    init_simple_test("STT4213");
    static STRUCT_IF_C STT4213 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4213)");
    check_field_offset(lv, fa, 0, "STT4213.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4213");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4213");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4213, STT4213)
//============================================================================


struct  STT4223  {
  __tsi64 fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT4223) C1{ FL Fi:18 Fl}



static void Test_STT4223()
{
  {
    init_simple_test("STT4223");
    static STRUCT_IF_C STT4223 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4223)");
    check_field_offset(lv, fa, 0, "STT4223.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4223");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4223");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4223, STT4223)
//============================================================================


struct  STT4233  {
  __tsi64 fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT4233) C1{ FL FL:18 Fl}



static void Test_STT4233()
{
  {
    init_simple_test("STT4233");
    static STRUCT_IF_C STT4233 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4233)");
    check_field_offset(lv, fa, 0, "STT4233.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4233");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4233");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4233, STT4233)
//============================================================================


struct  STT4243  {
  __tsi64 fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT4243) C1{ FL FL:48 Fl}



static void Test_STT4243()
{
  {
    init_simple_test("STT4243");
    static STRUCT_IF_C STT4243 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4243)");
    check_field_offset(lv, fa, 0, "STT4243.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4243");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4243");
    check_field_offset(lv, fb, 16, "STT4243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4243, STT4243)
//============================================================================


struct  STT414  {
  __tsi64 fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT414) C1{ FL Fc:0 FL}



static void Test_STT414()
{
  {
    init_simple_test("STT414");
    static STRUCT_IF_C STT414 lv;
    check2(sizeof(lv), 16, "sizeof(STT414)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT414)");
    check_field_offset(lv, fa, 0, "STT414.fa");
    check_field_offset(lv, fb, 8, "STT414.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT414, STT414)
//============================================================================


struct  STT424  {
  __tsi64 fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT424) C1{ FL Fs:0 FL}



static void Test_STT424()
{
  {
    init_simple_test("STT424");
    static STRUCT_IF_C STT424 lv;
    check2(sizeof(lv), 16, "sizeof(STT424)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT424)");
    check_field_offset(lv, fa, 0, "STT424.fa");
    check_field_offset(lv, fb, 8, "STT424.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT424, STT424)
//============================================================================


struct  STT434  {
  __tsi64 fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT434) C1{ FL Fi:0 FL}



static void Test_STT434()
{
  {
    init_simple_test("STT434");
    static STRUCT_IF_C STT434 lv;
    check2(sizeof(lv), 16, "sizeof(STT434)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT434)");
    check_field_offset(lv, fa, 0, "STT434.fa");
    check_field_offset(lv, fb, 8, "STT434.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT434, STT434)
//============================================================================


struct  STT444  {
  __tsi64 fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT444) C1{ FL FL:0 FL}



static void Test_STT444()
{
  {
    init_simple_test("STT444");
    static STRUCT_IF_C STT444 lv;
    check2(sizeof(lv), 16, "sizeof(STT444)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT444)");
    check_field_offset(lv, fa, 0, "STT444.fa");
    check_field_offset(lv, fb, 8, "STT444.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT444, STT444)
//============================================================================


struct  STT454  {
  __tsi64 fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT454) C1{ FL Fc:3 FL}



static void Test_STT454()
{
  {
    init_simple_test("STT454");
    static STRUCT_IF_C STT454 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT454)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT454)");
    check_field_offset(lv, fa, 0, "STT454.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT454.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT454, STT454)
//============================================================================


struct  STT464  {
  __tsi64 fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT464) C1{ FL Fs:3 FL}



static void Test_STT464()
{
  {
    init_simple_test("STT464");
    static STRUCT_IF_C STT464 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT464)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT464)");
    check_field_offset(lv, fa, 0, "STT464.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT464.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT464, STT464)
//============================================================================


struct  STT474  {
  __tsi64 fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT474) C1{ FL Fi:3 FL}



static void Test_STT474()
{
  {
    init_simple_test("STT474");
    static STRUCT_IF_C STT474 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT474)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT474)");
    check_field_offset(lv, fa, 0, "STT474.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT474.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT474, STT474)
//============================================================================


struct  STT484  {
  __tsi64 fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT484) C1{ FL FL:3 FL}



static void Test_STT484()
{
  {
    init_simple_test("STT484");
    static STRUCT_IF_C STT484 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT484)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT484)");
    check_field_offset(lv, fa, 0, "STT484.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT484.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT484, STT484)
//============================================================================


struct  STT494  {
  __tsi64 fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT494) C1{ FL Fs:8 FL}



static void Test_STT494()
{
  {
    init_simple_test("STT494");
    static STRUCT_IF_C STT494 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT494)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT494)");
    check_field_offset(lv, fa, 0, "STT494.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT494.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT494, STT494)
//============================================================================


struct  STT4104  {
  __tsi64 fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT4104) C1{ FL Fi:8 FL}



static void Test_STT4104()
{
  {
    init_simple_test("STT4104");
    static STRUCT_IF_C STT4104 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4104)");
    check_field_offset(lv, fa, 0, "STT4104.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4104, STT4104)
//============================================================================


struct  STT4114  {
  __tsi64 fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT4114) C1{ FL FL:8 FL}



static void Test_STT4114()
{
  {
    init_simple_test("STT4114");
    static STRUCT_IF_C STT4114 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4114)");
    check_field_offset(lv, fa, 0, "STT4114.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4114, STT4114)
//============================================================================


struct  STT4124  {
  __tsi64 fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT4124) C1{ FL Fi:18 FL}



static void Test_STT4124()
{
  {
    init_simple_test("STT4124");
    static STRUCT_IF_C STT4124 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4124)");
    check_field_offset(lv, fa, 0, "STT4124.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4124, STT4124)
//============================================================================


struct  STT4134  {
  __tsi64 fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT4134) C1{ FL FL:18 FL}



static void Test_STT4134()
{
  {
    init_simple_test("STT4134");
    static STRUCT_IF_C STT4134 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4134)");
    check_field_offset(lv, fa, 0, "STT4134.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4134, STT4134)
//============================================================================


struct  STT4144  {
  __tsi64 fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT4144) C1{ FL FL:48 FL}



static void Test_STT4144()
{
  {
    init_simple_test("STT4144");
    static STRUCT_IF_C STT4144 lv;
    check2(sizeof(lv), 24, "sizeof(STT4144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4144)");
    check_field_offset(lv, fa, 0, "STT4144.fa");
    check_field_offset(lv, fb, 16, "STT4144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4144, STT4144)
//============================================================================


struct  STT4154  {
  __tsi64 fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT4154) C1{ FL Fc:3 FL}



static void Test_STT4154()
{
  {
    init_simple_test("STT4154");
    static STRUCT_IF_C STT4154 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4154)");
    check_field_offset(lv, fa, 0, "STT4154.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4154");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4154");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4154, STT4154)
//============================================================================


struct  STT4164  {
  __tsi64 fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT4164) C1{ FL Fs:3 FL}



static void Test_STT4164()
{
  {
    init_simple_test("STT4164");
    static STRUCT_IF_C STT4164 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4164)");
    check_field_offset(lv, fa, 0, "STT4164.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4164");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4164");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4164, STT4164)
//============================================================================


struct  STT4174  {
  __tsi64 fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT4174) C1{ FL Fi:3 FL}



static void Test_STT4174()
{
  {
    init_simple_test("STT4174");
    static STRUCT_IF_C STT4174 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4174)");
    check_field_offset(lv, fa, 0, "STT4174.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4174");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4174");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4174, STT4174)
//============================================================================


struct  STT4184  {
  __tsi64 fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT4184) C1{ FL FL:3 FL}



static void Test_STT4184()
{
  {
    init_simple_test("STT4184");
    static STRUCT_IF_C STT4184 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4184)");
    check_field_offset(lv, fa, 0, "STT4184.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4184");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4184");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4184, STT4184)
//============================================================================


struct  STT4194  {
  __tsi64 fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT4194) C1{ FL Fs:8 FL}



static void Test_STT4194()
{
  {
    init_simple_test("STT4194");
    static STRUCT_IF_C STT4194 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4194)");
    check_field_offset(lv, fa, 0, "STT4194.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4194");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4194");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4194, STT4194)
//============================================================================


struct  STT4204  {
  __tsi64 fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT4204) C1{ FL Fi:8 FL}



static void Test_STT4204()
{
  {
    init_simple_test("STT4204");
    static STRUCT_IF_C STT4204 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4204)");
    check_field_offset(lv, fa, 0, "STT4204.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4204");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4204");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4204, STT4204)
//============================================================================


struct  STT4214  {
  __tsi64 fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT4214) C1{ FL FL:8 FL}



static void Test_STT4214()
{
  {
    init_simple_test("STT4214");
    static STRUCT_IF_C STT4214 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4214)");
    check_field_offset(lv, fa, 0, "STT4214.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4214");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4214");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4214, STT4214)
//============================================================================


struct  STT4224  {
  __tsi64 fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT4224) C1{ FL Fi:18 FL}



static void Test_STT4224()
{
  {
    init_simple_test("STT4224");
    static STRUCT_IF_C STT4224 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4224)");
    check_field_offset(lv, fa, 0, "STT4224.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4224");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4224");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4224, STT4224)
//============================================================================


struct  STT4234  {
  __tsi64 fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT4234) C1{ FL FL:18 FL}



static void Test_STT4234()
{
  {
    init_simple_test("STT4234");
    static STRUCT_IF_C STT4234 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4234)");
    check_field_offset(lv, fa, 0, "STT4234.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4234");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4234");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4234, STT4234)
//============================================================================


struct  STT4244  {
  __tsi64 fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT4244) C1{ FL FL:48 FL}



static void Test_STT4244()
{
  {
    init_simple_test("STT4244");
    static STRUCT_IF_C STT4244 lv;
    check2(sizeof(lv), 24, "sizeof(STT4244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4244)");
    check_field_offset(lv, fa, 0, "STT4244.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4244");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4244");
    check_field_offset(lv, fb, 16, "STT4244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4244, STT4244)
//============================================================================


struct  STT415  {
  __tsi64 fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT415) C1{ FL Fc:0 Fp}



static void Test_STT415()
{
  {
    init_simple_test("STT415");
    static STRUCT_IF_C STT415 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT415)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT415)");
    check_field_offset(lv, fa, 0, "STT415.fa");
    check_field_offset(lv, fb, 8, "STT415.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT415, STT415)
//============================================================================


struct  STT425  {
  __tsi64 fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT425) C1{ FL Fs:0 Fp}



static void Test_STT425()
{
  {
    init_simple_test("STT425");
    static STRUCT_IF_C STT425 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT425)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT425)");
    check_field_offset(lv, fa, 0, "STT425.fa");
    check_field_offset(lv, fb, 8, "STT425.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT425, STT425)
//============================================================================


struct  STT435  {
  __tsi64 fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT435) C1{ FL Fi:0 Fp}



static void Test_STT435()
{
  {
    init_simple_test("STT435");
    static STRUCT_IF_C STT435 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT435)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT435)");
    check_field_offset(lv, fa, 0, "STT435.fa");
    check_field_offset(lv, fb, 8, "STT435.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT435, STT435)
//============================================================================


struct  STT445  {
  __tsi64 fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT445) C1{ FL FL:0 Fp}



static void Test_STT445()
{
  {
    init_simple_test("STT445");
    static STRUCT_IF_C STT445 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT445)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT445)");
    check_field_offset(lv, fa, 0, "STT445.fa");
    check_field_offset(lv, fb, 8, "STT445.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT445, STT445)
//============================================================================


struct  STT455  {
  __tsi64 fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT455) C1{ FL Fc:3 Fp}



static void Test_STT455()
{
  {
    init_simple_test("STT455");
    static STRUCT_IF_C STT455 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT455)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT455)");
    check_field_offset(lv, fa, 0, "STT455.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT455.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT455, STT455)
//============================================================================


struct  STT465  {
  __tsi64 fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT465) C1{ FL Fs:3 Fp}



static void Test_STT465()
{
  {
    init_simple_test("STT465");
    static STRUCT_IF_C STT465 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT465)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT465)");
    check_field_offset(lv, fa, 0, "STT465.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT465.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT465, STT465)
//============================================================================


struct  STT475  {
  __tsi64 fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT475) C1{ FL Fi:3 Fp}



static void Test_STT475()
{
  {
    init_simple_test("STT475");
    static STRUCT_IF_C STT475 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT475)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT475)");
    check_field_offset(lv, fa, 0, "STT475.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT475.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT475, STT475)
//============================================================================


struct  STT485  {
  __tsi64 fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT485) C1{ FL FL:3 Fp}



static void Test_STT485()
{
  {
    init_simple_test("STT485");
    static STRUCT_IF_C STT485 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT485)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT485)");
    check_field_offset(lv, fa, 0, "STT485.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT485.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT485, STT485)
//============================================================================


struct  STT495  {
  __tsi64 fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT495) C1{ FL Fs:8 Fp}



static void Test_STT495()
{
  {
    init_simple_test("STT495");
    static STRUCT_IF_C STT495 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT495)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT495)");
    check_field_offset(lv, fa, 0, "STT495.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT495.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT495, STT495)
//============================================================================


struct  STT4105  {
  __tsi64 fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT4105) C1{ FL Fi:8 Fp}



static void Test_STT4105()
{
  {
    init_simple_test("STT4105");
    static STRUCT_IF_C STT4105 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4105)");
    check_field_offset(lv, fa, 0, "STT4105.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4105, STT4105)
//============================================================================


struct  STT4115  {
  __tsi64 fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT4115) C1{ FL FL:8 Fp}



static void Test_STT4115()
{
  {
    init_simple_test("STT4115");
    static STRUCT_IF_C STT4115 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4115)");
    check_field_offset(lv, fa, 0, "STT4115.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4115, STT4115)
//============================================================================


struct  STT4125  {
  __tsi64 fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT4125) C1{ FL Fi:18 Fp}



static void Test_STT4125()
{
  {
    init_simple_test("STT4125");
    static STRUCT_IF_C STT4125 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4125)");
    check_field_offset(lv, fa, 0, "STT4125.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4125, STT4125)
//============================================================================


struct  STT4135  {
  __tsi64 fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT4135) C1{ FL FL:18 Fp}



static void Test_STT4135()
{
  {
    init_simple_test("STT4135");
    static STRUCT_IF_C STT4135 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4135)");
    check_field_offset(lv, fa, 0, "STT4135.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4135, STT4135)
//============================================================================


struct  STT4145  {
  __tsi64 fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT4145) C1{ FL FL:48 Fp}



static void Test_STT4145()
{
  {
    init_simple_test("STT4145");
    static STRUCT_IF_C STT4145 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4145)");
    check_field_offset(lv, fa, 0, "STT4145.fa");
    check_field_offset(lv, fb, 16, "STT4145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4145, STT4145)
//============================================================================


struct  STT4155  {
  __tsi64 fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT4155) C1{ FL Fc:3 Fp}



static void Test_STT4155()
{
  {
    init_simple_test("STT4155");
    static STRUCT_IF_C STT4155 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4155)");
    check_field_offset(lv, fa, 0, "STT4155.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4155");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4155");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4155, STT4155)
//============================================================================


struct  STT4165  {
  __tsi64 fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT4165) C1{ FL Fs:3 Fp}



static void Test_STT4165()
{
  {
    init_simple_test("STT4165");
    static STRUCT_IF_C STT4165 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4165)");
    check_field_offset(lv, fa, 0, "STT4165.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4165");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4165");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4165, STT4165)
//============================================================================


struct  STT4175  {
  __tsi64 fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT4175) C1{ FL Fi:3 Fp}



static void Test_STT4175()
{
  {
    init_simple_test("STT4175");
    static STRUCT_IF_C STT4175 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4175)");
    check_field_offset(lv, fa, 0, "STT4175.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4175");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4175");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4175, STT4175)
//============================================================================


struct  STT4185  {
  __tsi64 fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT4185) C1{ FL FL:3 Fp}



static void Test_STT4185()
{
  {
    init_simple_test("STT4185");
    static STRUCT_IF_C STT4185 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4185)");
    check_field_offset(lv, fa, 0, "STT4185.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4185");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4185");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4185, STT4185)
//============================================================================


struct  STT4195  {
  __tsi64 fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT4195) C1{ FL Fs:8 Fp}



static void Test_STT4195()
{
  {
    init_simple_test("STT4195");
    static STRUCT_IF_C STT4195 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4195)");
    check_field_offset(lv, fa, 0, "STT4195.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4195");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4195");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4195, STT4195)
//============================================================================


struct  STT4205  {
  __tsi64 fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT4205) C1{ FL Fi:8 Fp}



static void Test_STT4205()
{
  {
    init_simple_test("STT4205");
    static STRUCT_IF_C STT4205 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4205)");
    check_field_offset(lv, fa, 0, "STT4205.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4205");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4205");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4205, STT4205)
//============================================================================


struct  STT4215  {
  __tsi64 fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT4215) C1{ FL FL:8 Fp}



static void Test_STT4215()
{
  {
    init_simple_test("STT4215");
    static STRUCT_IF_C STT4215 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4215)");
    check_field_offset(lv, fa, 0, "STT4215.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4215");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4215");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4215, STT4215)
//============================================================================


struct  STT4225  {
  __tsi64 fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT4225) C1{ FL Fi:18 Fp}



static void Test_STT4225()
{
  {
    init_simple_test("STT4225");
    static STRUCT_IF_C STT4225 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4225)");
    check_field_offset(lv, fa, 0, "STT4225.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4225");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4225");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4225, STT4225)
//============================================================================


struct  STT4235  {
  __tsi64 fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT4235) C1{ FL FL:18 Fp}



static void Test_STT4235()
{
  {
    init_simple_test("STT4235");
    static STRUCT_IF_C STT4235 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT4235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4235)");
    check_field_offset(lv, fa, 0, "STT4235.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4235");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4235");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4235, STT4235)
//============================================================================


struct  STT4245  {
  __tsi64 fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT4245) C1{ FL FL:48 Fp}



static void Test_STT4245()
{
  {
    init_simple_test("STT4245");
    static STRUCT_IF_C STT4245 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4245)");
    check_field_offset(lv, fa, 0, "STT4245.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4245");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4245");
    check_field_offset(lv, fb, 16, "STT4245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4245, STT4245)
//============================================================================


struct  STT416  {
  __tsi64 fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT416) C1{ FL Fc:0 Fi}



static void Test_STT416()
{
  {
    init_simple_test("STT416");
    static STRUCT_IF_C STT416 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT416)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT416)");
    check_field_offset(lv, fa, 0, "STT416.fa");
    check_field_offset(lv, fb, 8, "STT416.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT416, STT416)
//============================================================================


struct  STT426  {
  __tsi64 fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT426) C1{ FL Fs:0 Fi}



static void Test_STT426()
{
  {
    init_simple_test("STT426");
    static STRUCT_IF_C STT426 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT426)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT426)");
    check_field_offset(lv, fa, 0, "STT426.fa");
    check_field_offset(lv, fb, 8, "STT426.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT426, STT426)
//============================================================================


struct  STT436  {
  __tsi64 fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT436) C1{ FL Fi:0 Fi}



static void Test_STT436()
{
  {
    init_simple_test("STT436");
    static STRUCT_IF_C STT436 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT436)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT436)");
    check_field_offset(lv, fa, 0, "STT436.fa");
    check_field_offset(lv, fb, 8, "STT436.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT436, STT436)
//============================================================================


struct  STT446  {
  __tsi64 fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT446) C1{ FL FL:0 Fi}



static void Test_STT446()
{
  {
    init_simple_test("STT446");
    static STRUCT_IF_C STT446 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT446)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT446)");
    check_field_offset(lv, fa, 0, "STT446.fa");
    check_field_offset(lv, fb, 8, "STT446.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT446, STT446)
//============================================================================


struct  STT456  {
  __tsi64 fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT456) C1{ FL Fc:3 Fi}



static void Test_STT456()
{
  {
    init_simple_test("STT456");
    static STRUCT_IF_C STT456 lv;
    check2(sizeof(lv), 16, "sizeof(STT456)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT456)");
    check_field_offset(lv, fa, 0, "STT456.fa");
    check_field_offset(lv, fb, 12, "STT456.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT456, STT456)
//============================================================================


struct  STT466  {
  __tsi64 fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT466) C1{ FL Fs:3 Fi}



static void Test_STT466()
{
  {
    init_simple_test("STT466");
    static STRUCT_IF_C STT466 lv;
    check2(sizeof(lv), 16, "sizeof(STT466)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT466)");
    check_field_offset(lv, fa, 0, "STT466.fa");
    check_field_offset(lv, fb, 12, "STT466.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT466, STT466)
//============================================================================


struct  STT476  {
  __tsi64 fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT476) C1{ FL Fi:3 Fi}



static void Test_STT476()
{
  {
    init_simple_test("STT476");
    static STRUCT_IF_C STT476 lv;
    check2(sizeof(lv), 16, "sizeof(STT476)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT476)");
    check_field_offset(lv, fa, 0, "STT476.fa");
    check_field_offset(lv, fb, 12, "STT476.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT476, STT476)
//============================================================================


struct  STT486  {
  __tsi64 fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT486) C1{ FL FL:3 Fi}



static void Test_STT486()
{
  {
    init_simple_test("STT486");
    static STRUCT_IF_C STT486 lv;
    check2(sizeof(lv), 16, "sizeof(STT486)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT486)");
    check_field_offset(lv, fa, 0, "STT486.fa");
    check_field_offset(lv, fb, 12, "STT486.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT486, STT486)
//============================================================================


struct  STT496  {
  __tsi64 fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT496) C1{ FL Fs:8 Fi}



static void Test_STT496()
{
  {
    init_simple_test("STT496");
    static STRUCT_IF_C STT496 lv;
    check2(sizeof(lv), 16, "sizeof(STT496)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT496)");
    check_field_offset(lv, fa, 0, "STT496.fa");
    check_field_offset(lv, fb, 12, "STT496.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT496, STT496)
//============================================================================


struct  STT4106  {
  __tsi64 fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT4106) C1{ FL Fi:8 Fi}



static void Test_STT4106()
{
  {
    init_simple_test("STT4106");
    static STRUCT_IF_C STT4106 lv;
    check2(sizeof(lv), 16, "sizeof(STT4106)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4106)");
    check_field_offset(lv, fa, 0, "STT4106.fa");
    check_field_offset(lv, fb, 12, "STT4106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4106, STT4106)
//============================================================================


struct  STT4116  {
  __tsi64 fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT4116) C1{ FL FL:8 Fi}



static void Test_STT4116()
{
  {
    init_simple_test("STT4116");
    static STRUCT_IF_C STT4116 lv;
    check2(sizeof(lv), 16, "sizeof(STT4116)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4116)");
    check_field_offset(lv, fa, 0, "STT4116.fa");
    check_field_offset(lv, fb, 12, "STT4116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4116, STT4116)
//============================================================================


struct  STT4126  {
  __tsi64 fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT4126) C1{ FL Fi:18 Fi}



static void Test_STT4126()
{
  {
    init_simple_test("STT4126");
    static STRUCT_IF_C STT4126 lv;
    check2(sizeof(lv), 16, "sizeof(STT4126)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4126)");
    check_field_offset(lv, fa, 0, "STT4126.fa");
    check_field_offset(lv, fb, 12, "STT4126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4126, STT4126)
//============================================================================


struct  STT4136  {
  __tsi64 fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT4136) C1{ FL FL:18 Fi}



static void Test_STT4136()
{
  {
    init_simple_test("STT4136");
    static STRUCT_IF_C STT4136 lv;
    check2(sizeof(lv), 16, "sizeof(STT4136)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4136)");
    check_field_offset(lv, fa, 0, "STT4136.fa");
    check_field_offset(lv, fb, 12, "STT4136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4136, STT4136)
//============================================================================


struct  STT4146  {
  __tsi64 fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT4146) C1{ FL FL:48 Fi}



static void Test_STT4146()
{
  {
    init_simple_test("STT4146");
    static STRUCT_IF_C STT4146 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4146)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4146)");
    check_field_offset(lv, fa, 0, "STT4146.fa");
    check_field_offset(lv, fb, 16, "STT4146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4146, STT4146)
//============================================================================


struct  STT4156  {
  __tsi64 fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT4156) C1{ FL Fc:3 Fi}



static void Test_STT4156()
{
  {
    init_simple_test("STT4156");
    static STRUCT_IF_C STT4156 lv;
    check2(sizeof(lv), 16, "sizeof(STT4156)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4156)");
    check_field_offset(lv, fa, 0, "STT4156.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4156");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4156");
    check_field_offset(lv, fb, 12, "STT4156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4156, STT4156)
//============================================================================


struct  STT4166  {
  __tsi64 fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT4166) C1{ FL Fs:3 Fi}



static void Test_STT4166()
{
  {
    init_simple_test("STT4166");
    static STRUCT_IF_C STT4166 lv;
    check2(sizeof(lv), 16, "sizeof(STT4166)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4166)");
    check_field_offset(lv, fa, 0, "STT4166.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4166");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4166");
    check_field_offset(lv, fb, 12, "STT4166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4166, STT4166)
//============================================================================


struct  STT4176  {
  __tsi64 fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT4176) C1{ FL Fi:3 Fi}



static void Test_STT4176()
{
  {
    init_simple_test("STT4176");
    static STRUCT_IF_C STT4176 lv;
    check2(sizeof(lv), 16, "sizeof(STT4176)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4176)");
    check_field_offset(lv, fa, 0, "STT4176.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4176");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4176");
    check_field_offset(lv, fb, 12, "STT4176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4176, STT4176)
//============================================================================


struct  STT4186  {
  __tsi64 fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT4186) C1{ FL FL:3 Fi}



static void Test_STT4186()
{
  {
    init_simple_test("STT4186");
    static STRUCT_IF_C STT4186 lv;
    check2(sizeof(lv), 16, "sizeof(STT4186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4186)");
    check_field_offset(lv, fa, 0, "STT4186.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4186");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4186");
    check_field_offset(lv, fb, 12, "STT4186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4186, STT4186)
//============================================================================


struct  STT4196  {
  __tsi64 fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT4196) C1{ FL Fs:8 Fi}



static void Test_STT4196()
{
  {
    init_simple_test("STT4196");
    static STRUCT_IF_C STT4196 lv;
    check2(sizeof(lv), 16, "sizeof(STT4196)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4196)");
    check_field_offset(lv, fa, 0, "STT4196.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4196");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4196");
    check_field_offset(lv, fb, 12, "STT4196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4196, STT4196)
//============================================================================


struct  STT4206  {
  __tsi64 fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT4206) C1{ FL Fi:8 Fi}



static void Test_STT4206()
{
  {
    init_simple_test("STT4206");
    static STRUCT_IF_C STT4206 lv;
    check2(sizeof(lv), 16, "sizeof(STT4206)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4206)");
    check_field_offset(lv, fa, 0, "STT4206.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4206");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4206");
    check_field_offset(lv, fb, 12, "STT4206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4206, STT4206)
//============================================================================


struct  STT4216  {
  __tsi64 fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT4216) C1{ FL FL:8 Fi}



static void Test_STT4216()
{
  {
    init_simple_test("STT4216");
    static STRUCT_IF_C STT4216 lv;
    check2(sizeof(lv), 16, "sizeof(STT4216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4216)");
    check_field_offset(lv, fa, 0, "STT4216.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4216");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4216");
    check_field_offset(lv, fb, 12, "STT4216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4216, STT4216)
//============================================================================


struct  STT4226  {
  __tsi64 fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT4226) C1{ FL Fi:18 Fi}



static void Test_STT4226()
{
  {
    init_simple_test("STT4226");
    static STRUCT_IF_C STT4226 lv;
    check2(sizeof(lv), 16, "sizeof(STT4226)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4226)");
    check_field_offset(lv, fa, 0, "STT4226.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4226");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4226");
    check_field_offset(lv, fb, 12, "STT4226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4226, STT4226)
//============================================================================


struct  STT4236  {
  __tsi64 fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT4236) C1{ FL FL:18 Fi}



static void Test_STT4236()
{
  {
    init_simple_test("STT4236");
    static STRUCT_IF_C STT4236 lv;
    check2(sizeof(lv), 16, "sizeof(STT4236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4236)");
    check_field_offset(lv, fa, 0, "STT4236.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4236");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4236");
    check_field_offset(lv, fb, 12, "STT4236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4236, STT4236)
//============================================================================


struct  STT4246  {
  __tsi64 fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT4246) C1{ FL FL:48 Fi}



static void Test_STT4246()
{
  {
    init_simple_test("STT4246");
    static STRUCT_IF_C STT4246 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4246)");
    check_field_offset(lv, fa, 0, "STT4246.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4246");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4246");
    check_field_offset(lv, fb, 16, "STT4246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4246, STT4246)
//============================================================================


struct  STT417  {
  __tsi64 fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT417) C1{ FL Fc:0 FL}



static void Test_STT417()
{
  {
    init_simple_test("STT417");
    static STRUCT_IF_C STT417 lv;
    check2(sizeof(lv), 16, "sizeof(STT417)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT417)");
    check_field_offset(lv, fa, 0, "STT417.fa");
    check_field_offset(lv, fb, 8, "STT417.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT417, STT417)
//============================================================================


struct  STT427  {
  __tsi64 fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT427) C1{ FL Fs:0 FL}



static void Test_STT427()
{
  {
    init_simple_test("STT427");
    static STRUCT_IF_C STT427 lv;
    check2(sizeof(lv), 16, "sizeof(STT427)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT427)");
    check_field_offset(lv, fa, 0, "STT427.fa");
    check_field_offset(lv, fb, 8, "STT427.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT427, STT427)
//============================================================================


struct  STT437  {
  __tsi64 fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT437) C1{ FL Fi:0 FL}



static void Test_STT437()
{
  {
    init_simple_test("STT437");
    static STRUCT_IF_C STT437 lv;
    check2(sizeof(lv), 16, "sizeof(STT437)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT437)");
    check_field_offset(lv, fa, 0, "STT437.fa");
    check_field_offset(lv, fb, 8, "STT437.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT437, STT437)
//============================================================================


struct  STT447  {
  __tsi64 fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT447) C1{ FL FL:0 FL}



static void Test_STT447()
{
  {
    init_simple_test("STT447");
    static STRUCT_IF_C STT447 lv;
    check2(sizeof(lv), 16, "sizeof(STT447)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT447)");
    check_field_offset(lv, fa, 0, "STT447.fa");
    check_field_offset(lv, fb, 8, "STT447.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT447, STT447)
//============================================================================


struct  STT457  {
  __tsi64 fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT457) C1{ FL Fc:3 FL}



static void Test_STT457()
{
  {
    init_simple_test("STT457");
    static STRUCT_IF_C STT457 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT457)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT457)");
    check_field_offset(lv, fa, 0, "STT457.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT457.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT457, STT457)
//============================================================================


struct  STT467  {
  __tsi64 fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT467) C1{ FL Fs:3 FL}



static void Test_STT467()
{
  {
    init_simple_test("STT467");
    static STRUCT_IF_C STT467 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT467)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT467)");
    check_field_offset(lv, fa, 0, "STT467.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT467.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT467, STT467)
//============================================================================


struct  STT477  {
  __tsi64 fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT477) C1{ FL Fi:3 FL}



static void Test_STT477()
{
  {
    init_simple_test("STT477");
    static STRUCT_IF_C STT477 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT477)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT477)");
    check_field_offset(lv, fa, 0, "STT477.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT477.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT477, STT477)
//============================================================================


struct  STT487  {
  __tsi64 fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT487) C1{ FL FL:3 FL}



static void Test_STT487()
{
  {
    init_simple_test("STT487");
    static STRUCT_IF_C STT487 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT487)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT487)");
    check_field_offset(lv, fa, 0, "STT487.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT487.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT487, STT487)
//============================================================================


struct  STT497  {
  __tsi64 fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT497) C1{ FL Fs:8 FL}



static void Test_STT497()
{
  {
    init_simple_test("STT497");
    static STRUCT_IF_C STT497 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT497)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT497)");
    check_field_offset(lv, fa, 0, "STT497.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT497.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT497, STT497)
//============================================================================


struct  STT4107  {
  __tsi64 fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT4107) C1{ FL Fi:8 FL}



static void Test_STT4107()
{
  {
    init_simple_test("STT4107");
    static STRUCT_IF_C STT4107 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4107)");
    check_field_offset(lv, fa, 0, "STT4107.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4107, STT4107)
//============================================================================


struct  STT4117  {
  __tsi64 fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT4117) C1{ FL FL:8 FL}



static void Test_STT4117()
{
  {
    init_simple_test("STT4117");
    static STRUCT_IF_C STT4117 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4117)");
    check_field_offset(lv, fa, 0, "STT4117.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4117, STT4117)
//============================================================================


struct  STT4127  {
  __tsi64 fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT4127) C1{ FL Fi:18 FL}



static void Test_STT4127()
{
  {
    init_simple_test("STT4127");
    static STRUCT_IF_C STT4127 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4127)");
    check_field_offset(lv, fa, 0, "STT4127.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4127, STT4127)
//============================================================================


struct  STT4137  {
  __tsi64 fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT4137) C1{ FL FL:18 FL}



static void Test_STT4137()
{
  {
    init_simple_test("STT4137");
    static STRUCT_IF_C STT4137 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4137)");
    check_field_offset(lv, fa, 0, "STT4137.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4137, STT4137)
//============================================================================


struct  STT4147  {
  __tsi64 fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT4147) C1{ FL FL:48 FL}



static void Test_STT4147()
{
  {
    init_simple_test("STT4147");
    static STRUCT_IF_C STT4147 lv;
    check2(sizeof(lv), 24, "sizeof(STT4147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4147)");
    check_field_offset(lv, fa, 0, "STT4147.fa");
    check_field_offset(lv, fb, 16, "STT4147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4147, STT4147)
//============================================================================


struct  STT4157  {
  __tsi64 fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT4157) C1{ FL Fc:3 FL}



static void Test_STT4157()
{
  {
    init_simple_test("STT4157");
    static STRUCT_IF_C STT4157 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4157)");
    check_field_offset(lv, fa, 0, "STT4157.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4157");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4157");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4157, STT4157)
//============================================================================


struct  STT4167  {
  __tsi64 fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT4167) C1{ FL Fs:3 FL}



static void Test_STT4167()
{
  {
    init_simple_test("STT4167");
    static STRUCT_IF_C STT4167 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4167)");
    check_field_offset(lv, fa, 0, "STT4167.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4167");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4167");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4167, STT4167)
//============================================================================


struct  STT4177  {
  __tsi64 fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT4177) C1{ FL Fi:3 FL}



static void Test_STT4177()
{
  {
    init_simple_test("STT4177");
    static STRUCT_IF_C STT4177 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4177)");
    check_field_offset(lv, fa, 0, "STT4177.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4177");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4177");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4177, STT4177)
//============================================================================


struct  STT4187  {
  __tsi64 fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT4187) C1{ FL FL:3 FL}



static void Test_STT4187()
{
  {
    init_simple_test("STT4187");
    static STRUCT_IF_C STT4187 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4187)");
    check_field_offset(lv, fa, 0, "STT4187.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4187");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4187");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4187, STT4187)
//============================================================================


struct  STT4197  {
  __tsi64 fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT4197) C1{ FL Fs:8 FL}



static void Test_STT4197()
{
  {
    init_simple_test("STT4197");
    static STRUCT_IF_C STT4197 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4197)");
    check_field_offset(lv, fa, 0, "STT4197.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4197");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4197");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4197, STT4197)
//============================================================================


struct  STT4207  {
  __tsi64 fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT4207) C1{ FL Fi:8 FL}



static void Test_STT4207()
{
  {
    init_simple_test("STT4207");
    static STRUCT_IF_C STT4207 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4207)");
    check_field_offset(lv, fa, 0, "STT4207.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4207");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4207");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4207, STT4207)
//============================================================================


struct  STT4217  {
  __tsi64 fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT4217) C1{ FL FL:8 FL}



static void Test_STT4217()
{
  {
    init_simple_test("STT4217");
    static STRUCT_IF_C STT4217 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4217)");
    check_field_offset(lv, fa, 0, "STT4217.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4217");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4217");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4217, STT4217)
//============================================================================


struct  STT4227  {
  __tsi64 fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT4227) C1{ FL Fi:18 FL}



static void Test_STT4227()
{
  {
    init_simple_test("STT4227");
    static STRUCT_IF_C STT4227 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4227)");
    check_field_offset(lv, fa, 0, "STT4227.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4227");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4227");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4227, STT4227)
//============================================================================


struct  STT4237  {
  __tsi64 fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT4237) C1{ FL FL:18 FL}



static void Test_STT4237()
{
  {
    init_simple_test("STT4237");
    static STRUCT_IF_C STT4237 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT4237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4237)");
    check_field_offset(lv, fa, 0, "STT4237.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4237");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4237");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4237, STT4237)
//============================================================================


struct  STT4247  {
  __tsi64 fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT4247) C1{ FL FL:48 FL}



static void Test_STT4247()
{
  {
    init_simple_test("STT4247");
    static STRUCT_IF_C STT4247 lv;
    check2(sizeof(lv), 24, "sizeof(STT4247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4247)");
    check_field_offset(lv, fa, 0, "STT4247.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4247");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4247");
    check_field_offset(lv, fb, 16, "STT4247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4247, STT4247)
//============================================================================


struct  STT418  {
  __tsi64 fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT418) C1{ FL Fc:0 FD}



static void Test_STT418()
{
  {
    init_simple_test("STT418");
    static STRUCT_IF_C STT418 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT418)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT418)");
    check_field_offset(lv, fa, 0, "STT418.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT418.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT418, STT418)
//============================================================================


struct  STT428  {
  __tsi64 fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT428) C1{ FL Fs:0 FD}



static void Test_STT428()
{
  {
    init_simple_test("STT428");
    static STRUCT_IF_C STT428 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT428)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT428)");
    check_field_offset(lv, fa, 0, "STT428.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT428.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT428, STT428)
//============================================================================


struct  STT438  {
  __tsi64 fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT438) C1{ FL Fi:0 FD}



static void Test_STT438()
{
  {
    init_simple_test("STT438");
    static STRUCT_IF_C STT438 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT438)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT438)");
    check_field_offset(lv, fa, 0, "STT438.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT438.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT438, STT438)
//============================================================================


struct  STT448  {
  __tsi64 fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT448) C1{ FL FL:0 FD}



static void Test_STT448()
{
  {
    init_simple_test("STT448");
    static STRUCT_IF_C STT448 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT448)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT448)");
    check_field_offset(lv, fa, 0, "STT448.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT448.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT448, STT448)
//============================================================================


struct  STT458  {
  __tsi64 fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT458) C1{ FL Fc:3 FD}



static void Test_STT458()
{
  {
    init_simple_test("STT458");
    static STRUCT_IF_C STT458 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT458)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT458)");
    check_field_offset(lv, fa, 0, "STT458.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT458.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT458, STT458)
//============================================================================


struct  STT468  {
  __tsi64 fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT468) C1{ FL Fs:3 FD}



static void Test_STT468()
{
  {
    init_simple_test("STT468");
    static STRUCT_IF_C STT468 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT468)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT468)");
    check_field_offset(lv, fa, 0, "STT468.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT468.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT468, STT468)
//============================================================================


struct  STT478  {
  __tsi64 fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT478) C1{ FL Fi:3 FD}



static void Test_STT478()
{
  {
    init_simple_test("STT478");
    static STRUCT_IF_C STT478 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT478)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT478)");
    check_field_offset(lv, fa, 0, "STT478.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT478.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT478, STT478)
//============================================================================


struct  STT488  {
  __tsi64 fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT488) C1{ FL FL:3 FD}



static void Test_STT488()
{
  {
    init_simple_test("STT488");
    static STRUCT_IF_C STT488 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT488)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT488)");
    check_field_offset(lv, fa, 0, "STT488.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT488.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT488, STT488)
//============================================================================


struct  STT498  {
  __tsi64 fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT498) C1{ FL Fs:8 FD}



static void Test_STT498()
{
  {
    init_simple_test("STT498");
    static STRUCT_IF_C STT498 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT498)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT498)");
    check_field_offset(lv, fa, 0, "STT498.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT498.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT498, STT498)
//============================================================================


struct  STT4108  {
  __tsi64 fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT4108) C1{ FL Fi:8 FD}



static void Test_STT4108()
{
  {
    init_simple_test("STT4108");
    static STRUCT_IF_C STT4108 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4108)");
    check_field_offset(lv, fa, 0, "STT4108.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4108, STT4108)
//============================================================================


struct  STT4118  {
  __tsi64 fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT4118) C1{ FL FL:8 FD}



static void Test_STT4118()
{
  {
    init_simple_test("STT4118");
    static STRUCT_IF_C STT4118 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4118)");
    check_field_offset(lv, fa, 0, "STT4118.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4118, STT4118)
//============================================================================


struct  STT4128  {
  __tsi64 fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT4128) C1{ FL Fi:18 FD}



static void Test_STT4128()
{
  {
    init_simple_test("STT4128");
    static STRUCT_IF_C STT4128 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4128)");
    check_field_offset(lv, fa, 0, "STT4128.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4128, STT4128)
//============================================================================


struct  STT4138  {
  __tsi64 fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT4138) C1{ FL FL:18 FD}



static void Test_STT4138()
{
  {
    init_simple_test("STT4138");
    static STRUCT_IF_C STT4138 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4138)");
    check_field_offset(lv, fa, 0, "STT4138.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4138, STT4138)
//============================================================================


struct  STT4148  {
  __tsi64 fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT4148) C1{ FL FL:48 FD}



static void Test_STT4148()
{
  {
    init_simple_test("STT4148");
    static STRUCT_IF_C STT4148 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT4148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4148)");
    check_field_offset(lv, fa, 0, "STT4148.fa");
    check_field_offset(lv, fb, 16, "STT4148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4148, STT4148)
//============================================================================


struct  STT4158  {
  __tsi64 fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT4158) C1{ FL Fc:3 FD}



static void Test_STT4158()
{
  {
    init_simple_test("STT4158");
    static STRUCT_IF_C STT4158 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4158)");
    check_field_offset(lv, fa, 0, "STT4158.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4158");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4158");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4158, STT4158)
//============================================================================


struct  STT4168  {
  __tsi64 fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT4168) C1{ FL Fs:3 FD}



static void Test_STT4168()
{
  {
    init_simple_test("STT4168");
    static STRUCT_IF_C STT4168 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4168)");
    check_field_offset(lv, fa, 0, "STT4168.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4168");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4168");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4168, STT4168)
//============================================================================


struct  STT4178  {
  __tsi64 fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT4178) C1{ FL Fi:3 FD}



static void Test_STT4178()
{
  {
    init_simple_test("STT4178");
    static STRUCT_IF_C STT4178 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4178)");
    check_field_offset(lv, fa, 0, "STT4178.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4178");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4178");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4178, STT4178)
//============================================================================


struct  STT4188  {
  __tsi64 fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT4188) C1{ FL FL:3 FD}



static void Test_STT4188()
{
  {
    init_simple_test("STT4188");
    static STRUCT_IF_C STT4188 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4188)");
    check_field_offset(lv, fa, 0, "STT4188.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4188");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4188");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4188, STT4188)
//============================================================================


struct  STT4198  {
  __tsi64 fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT4198) C1{ FL Fs:8 FD}



static void Test_STT4198()
{
  {
    init_simple_test("STT4198");
    static STRUCT_IF_C STT4198 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4198)");
    check_field_offset(lv, fa, 0, "STT4198.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4198");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4198");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4198, STT4198)
//============================================================================


struct  STT4208  {
  __tsi64 fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT4208) C1{ FL Fi:8 FD}



static void Test_STT4208()
{
  {
    init_simple_test("STT4208");
    static STRUCT_IF_C STT4208 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4208)");
    check_field_offset(lv, fa, 0, "STT4208.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4208");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4208");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4208, STT4208)
//============================================================================


struct  STT4218  {
  __tsi64 fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT4218) C1{ FL FL:8 FD}



static void Test_STT4218()
{
  {
    init_simple_test("STT4218");
    static STRUCT_IF_C STT4218 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4218)");
    check_field_offset(lv, fa, 0, "STT4218.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4218");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4218");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4218, STT4218)
//============================================================================


struct  STT4228  {
  __tsi64 fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT4228) C1{ FL Fi:18 FD}



static void Test_STT4228()
{
  {
    init_simple_test("STT4228");
    static STRUCT_IF_C STT4228 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4228)");
    check_field_offset(lv, fa, 0, "STT4228.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4228");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4228");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4228, STT4228)
//============================================================================


struct  STT4238  {
  __tsi64 fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT4238) C1{ FL FL:18 FD}



static void Test_STT4238()
{
  {
    init_simple_test("STT4238");
    static STRUCT_IF_C STT4238 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT4238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4238)");
    check_field_offset(lv, fa, 0, "STT4238.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4238");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4238");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT4238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4238, STT4238)
//============================================================================


struct  STT4248  {
  __tsi64 fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT4248) C1{ FL FL:48 FD}



static void Test_STT4248()
{
  {
    init_simple_test("STT4248");
    static STRUCT_IF_C STT4248 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT4248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT4248)");
    check_field_offset(lv, fa, 0, "STT4248.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4248");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4248");
    check_field_offset(lv, fb, 16, "STT4248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4248, STT4248)
//============================================================================


struct  STT419  {
  __tsi64 fa;
  unsigned char  :0;
};
//SIG(1 STT419) C1{ FL Fc:0}



static void Test_STT419()
{
  {
    init_simple_test("STT419");
    static STRUCT_IF_C STT419 lv;
    check2(sizeof(lv), 8, "sizeof(STT419)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT419)");
    check_field_offset(lv, fa, 0, "STT419.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT419, STT419)
//============================================================================


struct  STT429  {
  __tsi64 fa;
  unsigned short  :0;
};
//SIG(1 STT429) C1{ FL Fs:0}



static void Test_STT429()
{
  {
    init_simple_test("STT429");
    static STRUCT_IF_C STT429 lv;
    check2(sizeof(lv), 8, "sizeof(STT429)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT429)");
    check_field_offset(lv, fa, 0, "STT429.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT429, STT429)
//============================================================================


struct  STT439  {
  __tsi64 fa;
  unsigned int  :0;
};
//SIG(1 STT439) C1{ FL Fi:0}



static void Test_STT439()
{
  {
    init_simple_test("STT439");
    static STRUCT_IF_C STT439 lv;
    check2(sizeof(lv), 8, "sizeof(STT439)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT439)");
    check_field_offset(lv, fa, 0, "STT439.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT439, STT439)
//============================================================================


struct  STT449  {
  __tsi64 fa;
  __tsu64  :0;
};
//SIG(1 STT449) C1{ FL FL:0}



static void Test_STT449()
{
  {
    init_simple_test("STT449");
    static STRUCT_IF_C STT449 lv;
    check2(sizeof(lv), 8, "sizeof(STT449)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT449)");
    check_field_offset(lv, fa, 0, "STT449.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT449, STT449)
//============================================================================


struct  STT459  {
  __tsi64 fa;
  unsigned char  :3;
};
//SIG(1 STT459) C1{ FL Fc:3}



static void Test_STT459()
{
  {
    init_simple_test("STT459");
    static STRUCT_IF_C STT459 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT459)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT459)");
    check_field_offset(lv, fa, 0, "STT459.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT459, STT459)
//============================================================================


struct  STT469  {
  __tsi64 fa;
  unsigned short  :3;
};
//SIG(1 STT469) C1{ FL Fs:3}



static void Test_STT469()
{
  {
    init_simple_test("STT469");
    static STRUCT_IF_C STT469 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT469)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT469)");
    check_field_offset(lv, fa, 0, "STT469.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT469, STT469)
//============================================================================


struct  STT479  {
  __tsi64 fa;
  unsigned int  :3;
};
//SIG(1 STT479) C1{ FL Fi:3}



static void Test_STT479()
{
  {
    init_simple_test("STT479");
    static STRUCT_IF_C STT479 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT479)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT479)");
    check_field_offset(lv, fa, 0, "STT479.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT479, STT479)
//============================================================================


struct  STT489  {
  __tsi64 fa;
  __tsu64  :3;
};
//SIG(1 STT489) C1{ FL FL:3}



static void Test_STT489()
{
  {
    init_simple_test("STT489");
    static STRUCT_IF_C STT489 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT489)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT489)");
    check_field_offset(lv, fa, 0, "STT489.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT489, STT489)
//============================================================================


struct  STT499  {
  __tsi64 fa;
  unsigned short  :8;
};
//SIG(1 STT499) C1{ FL Fs:8}



static void Test_STT499()
{
  {
    init_simple_test("STT499");
    static STRUCT_IF_C STT499 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT499)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT499)");
    check_field_offset(lv, fa, 0, "STT499.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT499, STT499)
//============================================================================


struct  STT4109  {
  __tsi64 fa;
  unsigned int  :8;
};
//SIG(1 STT4109) C1{ FL Fi:8}



static void Test_STT4109()
{
  {
    init_simple_test("STT4109");
    static STRUCT_IF_C STT4109 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4109)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4109)");
    check_field_offset(lv, fa, 0, "STT4109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4109, STT4109)
//============================================================================


struct  STT4119  {
  __tsi64 fa;
  __tsu64  :8;
};
//SIG(1 STT4119) C1{ FL FL:8}



static void Test_STT4119()
{
  {
    init_simple_test("STT4119");
    static STRUCT_IF_C STT4119 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4119)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4119)");
    check_field_offset(lv, fa, 0, "STT4119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4119, STT4119)
//============================================================================


struct  STT4129  {
  __tsi64 fa;
  unsigned int  :18;
};
//SIG(1 STT4129) C1{ FL Fi:18}



static void Test_STT4129()
{
  {
    init_simple_test("STT4129");
    static STRUCT_IF_C STT4129 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4129)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4129)");
    check_field_offset(lv, fa, 0, "STT4129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4129, STT4129)
//============================================================================


struct  STT4139  {
  __tsi64 fa;
  __tsu64  :18;
};
//SIG(1 STT4139) C1{ FL FL:18}



static void Test_STT4139()
{
  {
    init_simple_test("STT4139");
    static STRUCT_IF_C STT4139 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4139)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4139)");
    check_field_offset(lv, fa, 0, "STT4139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4139, STT4139)
//============================================================================


struct  STT4149  {
  __tsi64 fa;
  __tsu64  :48;
};
//SIG(1 STT4149) C1{ FL FL:48}



static void Test_STT4149()
{
  {
    init_simple_test("STT4149");
    static STRUCT_IF_C STT4149 lv;
    check2(sizeof(lv), 16, "sizeof(STT4149)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4149)");
    check_field_offset(lv, fa, 0, "STT4149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4149, STT4149)
//============================================================================


struct  STT4159  {
  __tsi64 fa;
  unsigned char bf:3;
};
//SIG(1 STT4159) C1{ FL Fc:3}



static void Test_STT4159()
{
  {
    init_simple_test("STT4159");
    static STRUCT_IF_C STT4159 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4159)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4159)");
    check_field_offset(lv, fa, 0, "STT4159.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4159");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4159, STT4159)
//============================================================================


struct  STT4169  {
  __tsi64 fa;
  unsigned short bf:3;
};
//SIG(1 STT4169) C1{ FL Fs:3}



static void Test_STT4169()
{
  {
    init_simple_test("STT4169");
    static STRUCT_IF_C STT4169 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4169)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4169)");
    check_field_offset(lv, fa, 0, "STT4169.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4169");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4169, STT4169)
//============================================================================


struct  STT4179  {
  __tsi64 fa;
  unsigned int bf:3;
};
//SIG(1 STT4179) C1{ FL Fi:3}



static void Test_STT4179()
{
  {
    init_simple_test("STT4179");
    static STRUCT_IF_C STT4179 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4179)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4179)");
    check_field_offset(lv, fa, 0, "STT4179.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4179");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4179, STT4179)
//============================================================================


struct  STT4189  {
  __tsi64 fa;
  __tsu64 bf:3;
};
//SIG(1 STT4189) C1{ FL FL:3}



static void Test_STT4189()
{
  {
    init_simple_test("STT4189");
    static STRUCT_IF_C STT4189 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4189)");
    check_field_offset(lv, fa, 0, "STT4189.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT4189");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT4189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4189, STT4189)
//============================================================================


struct  STT4199  {
  __tsi64 fa;
  unsigned short bf:8;
};
//SIG(1 STT4199) C1{ FL Fs:8}



static void Test_STT4199()
{
  {
    init_simple_test("STT4199");
    static STRUCT_IF_C STT4199 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4199)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4199)");
    check_field_offset(lv, fa, 0, "STT4199.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4199");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4199, STT4199)
//============================================================================


struct  STT4209  {
  __tsi64 fa;
  unsigned int bf:8;
};
//SIG(1 STT4209) C1{ FL Fi:8}



static void Test_STT4209()
{
  {
    init_simple_test("STT4209");
    static STRUCT_IF_C STT4209 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4209)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4209)");
    check_field_offset(lv, fa, 0, "STT4209.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4209");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4209, STT4209)
//============================================================================


struct  STT4219  {
  __tsi64 fa;
  __tsu64 bf:8;
};
//SIG(1 STT4219) C1{ FL FL:8}



static void Test_STT4219()
{
  {
    init_simple_test("STT4219");
    static STRUCT_IF_C STT4219 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4219)");
    check_field_offset(lv, fa, 0, "STT4219.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT4219");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT4219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4219, STT4219)
//============================================================================


struct  STT4229  {
  __tsi64 fa;
  unsigned int bf:18;
};
//SIG(1 STT4229) C1{ FL Fi:18}



static void Test_STT4229()
{
  {
    init_simple_test("STT4229");
    static STRUCT_IF_C STT4229 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4229)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4229)");
    check_field_offset(lv, fa, 0, "STT4229.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4229");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4229, STT4229)
//============================================================================


struct  STT4239  {
  __tsi64 fa;
  __tsu64 bf:18;
};
//SIG(1 STT4239) C1{ FL FL:18}



static void Test_STT4239()
{
  {
    init_simple_test("STT4239");
    static STRUCT_IF_C STT4239 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT4239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4239)");
    check_field_offset(lv, fa, 0, "STT4239.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT4239");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT4239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4239, STT4239)
//============================================================================


struct  STT4249  {
  __tsi64 fa;
  __tsu64 bf:48;
};
//SIG(1 STT4249) C1{ FL FL:48}



static void Test_STT4249()
{
  {
    init_simple_test("STT4249");
    static STRUCT_IF_C STT4249 lv;
    check2(sizeof(lv), 16, "sizeof(STT4249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT4249)");
    check_field_offset(lv, fa, 0, "STT4249.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT4249");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT4249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT4249, STT4249)
//============================================================================


struct  STT510  {
  void *fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT510) C1{ Fp Fc:0 Fc}



static void Test_STT510()
{
  {
    init_simple_test("STT510");
    static STRUCT_IF_C STT510 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT510)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT510)");
    check_field_offset(lv, fa, 0, "STT510.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT510.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT510, STT510)
//============================================================================


struct  STT520  {
  void *fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT520) C1{ Fp Fs:0 Fc}



static void Test_STT520()
{
  {
    init_simple_test("STT520");
    static STRUCT_IF_C STT520 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT520)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT520)");
    check_field_offset(lv, fa, 0, "STT520.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT520.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT520, STT520)
//============================================================================


struct  STT530  {
  void *fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT530) C1{ Fp Fi:0 Fc}



static void Test_STT530()
{
  {
    init_simple_test("STT530");
    static STRUCT_IF_C STT530 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT530)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT530)");
    check_field_offset(lv, fa, 0, "STT530.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT530.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT530, STT530)
//============================================================================


struct  STT540  {
  void *fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT540) C1{ Fp FL:0 Fc}



static void Test_STT540()
{
  {
    init_simple_test("STT540");
    static STRUCT_IF_C STT540 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT540)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT540)");
    check_field_offset(lv, fa, 0, "STT540.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT540.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT540, STT540)
//============================================================================


struct  STT550  {
  void *fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT550) C1{ Fp Fc:3 Fc}



static void Test_STT550()
{
  {
    init_simple_test("STT550");
    static STRUCT_IF_C STT550 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT550)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT550)");
    check_field_offset(lv, fa, 0, "STT550.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT550.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT550, STT550)
//============================================================================


struct  STT560  {
  void *fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT560) C1{ Fp Fs:3 Fc}



static void Test_STT560()
{
  {
    init_simple_test("STT560");
    static STRUCT_IF_C STT560 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT560)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT560)");
    check_field_offset(lv, fa, 0, "STT560.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT560.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT560, STT560)
//============================================================================


struct  STT570  {
  void *fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT570) C1{ Fp Fi:3 Fc}



static void Test_STT570()
{
  {
    init_simple_test("STT570");
    static STRUCT_IF_C STT570 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT570)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT570)");
    check_field_offset(lv, fa, 0, "STT570.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT570.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT570, STT570)
//============================================================================


struct  STT580  {
  void *fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT580) C1{ Fp FL:3 Fc}



static void Test_STT580()
{
  {
    init_simple_test("STT580");
    static STRUCT_IF_C STT580 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT580)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT580)");
    check_field_offset(lv, fa, 0, "STT580.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT580.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT580, STT580)
//============================================================================


struct  STT590  {
  void *fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT590) C1{ Fp Fs:8 Fc}



static void Test_STT590()
{
  {
    init_simple_test("STT590");
    static STRUCT_IF_C STT590 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT590)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT590)");
    check_field_offset(lv, fa, 0, "STT590.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT590.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT590, STT590)
//============================================================================


struct  STT5100  {
  void *fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT5100) C1{ Fp Fi:8 Fc}



static void Test_STT5100()
{
  {
    init_simple_test("STT5100");
    static STRUCT_IF_C STT5100 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5100)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5100)");
    check_field_offset(lv, fa, 0, "STT5100.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5100, STT5100)
//============================================================================


struct  STT5110  {
  void *fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT5110) C1{ Fp FL:8 Fc}



static void Test_STT5110()
{
  {
    init_simple_test("STT5110");
    static STRUCT_IF_C STT5110 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5110)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5110)");
    check_field_offset(lv, fa, 0, "STT5110.fa");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5110, STT5110)
//============================================================================


struct  STT5120  {
  void *fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT5120) C1{ Fp Fi:18 Fc}



static void Test_STT5120()
{
  {
    init_simple_test("STT5120");
    static STRUCT_IF_C STT5120 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5120)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5120)");
    check_field_offset(lv, fa, 0, "STT5120.fa");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT5120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5120, STT5120)
//============================================================================


struct  STT5130  {
  void *fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT5130) C1{ Fp FL:18 Fc}



static void Test_STT5130()
{
  {
    init_simple_test("STT5130");
    static STRUCT_IF_C STT5130 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5130)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5130)");
    check_field_offset(lv, fa, 0, "STT5130.fa");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT5130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5130, STT5130)
//============================================================================


struct  STT5140  {
  void *fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT5140) C1{ Fp FL:48 Fc}



static void Test_STT5140()
{
  {
    init_simple_test("STT5140");
    static STRUCT_IF_C STT5140 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5140)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5140)");
    check_field_offset(lv, fa, 0, "STT5140.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT5140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5140, STT5140)
//============================================================================


struct  STT5150  {
  void *fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT5150) C1{ Fp Fc:3 Fc}



static void Test_STT5150()
{
  {
    init_simple_test("STT5150");
    static STRUCT_IF_C STT5150 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5150)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5150)");
    check_field_offset(lv, fa, 0, "STT5150.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5150");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5150");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5150, STT5150)
//============================================================================


struct  STT5160  {
  void *fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT5160) C1{ Fp Fs:3 Fc}



static void Test_STT5160()
{
  {
    init_simple_test("STT5160");
    static STRUCT_IF_C STT5160 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5160)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5160)");
    check_field_offset(lv, fa, 0, "STT5160.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5160");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5160");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5160, STT5160)
//============================================================================


struct  STT5170  {
  void *fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT5170) C1{ Fp Fi:3 Fc}



static void Test_STT5170()
{
  {
    init_simple_test("STT5170");
    static STRUCT_IF_C STT5170 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5170)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5170)");
    check_field_offset(lv, fa, 0, "STT5170.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5170");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5170");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5170, STT5170)
//============================================================================


struct  STT5180  {
  void *fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT5180) C1{ Fp FL:3 Fc}



static void Test_STT5180()
{
  {
    init_simple_test("STT5180");
    static STRUCT_IF_C STT5180 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5180)");
    check_field_offset(lv, fa, 0, "STT5180.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5180");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5180");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5180, STT5180)
//============================================================================


struct  STT5190  {
  void *fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT5190) C1{ Fp Fs:8 Fc}



static void Test_STT5190()
{
  {
    init_simple_test("STT5190");
    static STRUCT_IF_C STT5190 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5190)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5190)");
    check_field_offset(lv, fa, 0, "STT5190.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5190");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5190");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5190, STT5190)
//============================================================================


struct  STT5200  {
  void *fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT5200) C1{ Fp Fi:8 Fc}



static void Test_STT5200()
{
  {
    init_simple_test("STT5200");
    static STRUCT_IF_C STT5200 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5200)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5200)");
    check_field_offset(lv, fa, 0, "STT5200.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5200");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5200");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5200, STT5200)
//============================================================================


struct  STT5210  {
  void *fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT5210) C1{ Fp FL:8 Fc}



static void Test_STT5210()
{
  {
    init_simple_test("STT5210");
    static STRUCT_IF_C STT5210 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5210)");
    check_field_offset(lv, fa, 0, "STT5210.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5210");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5210");
    check_field_offset(lv, fb, ABISELECT(9,5), "STT5210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5210, STT5210)
//============================================================================


struct  STT5220  {
  void *fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT5220) C1{ Fp Fi:18 Fc}



static void Test_STT5220()
{
  {
    init_simple_test("STT5220");
    static STRUCT_IF_C STT5220 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5220)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5220)");
    check_field_offset(lv, fa, 0, "STT5220.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5220");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5220");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT5220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5220, STT5220)
//============================================================================


struct  STT5230  {
  void *fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT5230) C1{ Fp FL:18 Fc}



static void Test_STT5230()
{
  {
    init_simple_test("STT5230");
    static STRUCT_IF_C STT5230 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5230)");
    check_field_offset(lv, fa, 0, "STT5230.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5230");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5230");
    check_field_offset(lv, fb, ABISELECT(11,7), "STT5230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5230, STT5230)
//============================================================================


struct  STT5240  {
  void *fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT5240) C1{ Fp FL:48 Fc}



static void Test_STT5240()
{
  {
    init_simple_test("STT5240");
    static STRUCT_IF_C STT5240 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5240)");
    check_field_offset(lv, fa, 0, "STT5240.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5240");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5240");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT5240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5240, STT5240)
//============================================================================


struct  STT511  {
  void *fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT511) C1{ Fp Fc:0 Fs}



static void Test_STT511()
{
  {
    init_simple_test("STT511");
    static STRUCT_IF_C STT511 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT511)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT511)");
    check_field_offset(lv, fa, 0, "STT511.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT511.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT511, STT511)
//============================================================================


struct  STT521  {
  void *fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT521) C1{ Fp Fs:0 Fs}



static void Test_STT521()
{
  {
    init_simple_test("STT521");
    static STRUCT_IF_C STT521 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT521)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT521)");
    check_field_offset(lv, fa, 0, "STT521.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT521.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT521, STT521)
//============================================================================


struct  STT531  {
  void *fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT531) C1{ Fp Fi:0 Fs}



static void Test_STT531()
{
  {
    init_simple_test("STT531");
    static STRUCT_IF_C STT531 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT531)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT531)");
    check_field_offset(lv, fa, 0, "STT531.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT531.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT531, STT531)
//============================================================================


struct  STT541  {
  void *fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT541) C1{ Fp FL:0 Fs}



static void Test_STT541()
{
  {
    init_simple_test("STT541");
    static STRUCT_IF_C STT541 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT541)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT541)");
    check_field_offset(lv, fa, 0, "STT541.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT541.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT541, STT541)
//============================================================================


struct  STT551  {
  void *fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT551) C1{ Fp Fc:3 Fs}



static void Test_STT551()
{
  {
    init_simple_test("STT551");
    static STRUCT_IF_C STT551 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT551)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT551)");
    check_field_offset(lv, fa, 0, "STT551.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT551.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT551, STT551)
//============================================================================


struct  STT561  {
  void *fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT561) C1{ Fp Fs:3 Fs}



static void Test_STT561()
{
  {
    init_simple_test("STT561");
    static STRUCT_IF_C STT561 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT561)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT561)");
    check_field_offset(lv, fa, 0, "STT561.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT561.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT561, STT561)
//============================================================================


struct  STT571  {
  void *fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT571) C1{ Fp Fi:3 Fs}



static void Test_STT571()
{
  {
    init_simple_test("STT571");
    static STRUCT_IF_C STT571 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT571)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT571)");
    check_field_offset(lv, fa, 0, "STT571.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT571.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT571, STT571)
//============================================================================


struct  STT581  {
  void *fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT581) C1{ Fp FL:3 Fs}



static void Test_STT581()
{
  {
    init_simple_test("STT581");
    static STRUCT_IF_C STT581 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT581)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT581)");
    check_field_offset(lv, fa, 0, "STT581.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT581.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT581, STT581)
//============================================================================


struct  STT591  {
  void *fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT591) C1{ Fp Fs:8 Fs}



static void Test_STT591()
{
  {
    init_simple_test("STT591");
    static STRUCT_IF_C STT591 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT591)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT591)");
    check_field_offset(lv, fa, 0, "STT591.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT591.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT591, STT591)
//============================================================================


struct  STT5101  {
  void *fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT5101) C1{ Fp Fi:8 Fs}



static void Test_STT5101()
{
  {
    init_simple_test("STT5101");
    static STRUCT_IF_C STT5101 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5101)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5101)");
    check_field_offset(lv, fa, 0, "STT5101.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5101, STT5101)
//============================================================================


struct  STT5111  {
  void *fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT5111) C1{ Fp FL:8 Fs}



static void Test_STT5111()
{
  {
    init_simple_test("STT5111");
    static STRUCT_IF_C STT5111 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5111)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5111)");
    check_field_offset(lv, fa, 0, "STT5111.fa");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5111, STT5111)
//============================================================================


struct  STT5121  {
  void *fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT5121) C1{ Fp Fi:18 Fs}



static void Test_STT5121()
{
  {
    init_simple_test("STT5121");
    static STRUCT_IF_C STT5121 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5121)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5121)");
    check_field_offset(lv, fa, 0, "STT5121.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5121, STT5121)
//============================================================================


struct  STT5131  {
  void *fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT5131) C1{ Fp FL:18 Fs}



static void Test_STT5131()
{
  {
    init_simple_test("STT5131");
    static STRUCT_IF_C STT5131 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5131)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5131)");
    check_field_offset(lv, fa, 0, "STT5131.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5131, STT5131)
//============================================================================


struct  STT5141  {
  void *fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT5141) C1{ Fp FL:48 Fs}



static void Test_STT5141()
{
  {
    init_simple_test("STT5141");
    static STRUCT_IF_C STT5141 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5141)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5141)");
    check_field_offset(lv, fa, 0, "STT5141.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT5141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5141, STT5141)
//============================================================================


struct  STT5151  {
  void *fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT5151) C1{ Fp Fc:3 Fs}



static void Test_STT5151()
{
  {
    init_simple_test("STT5151");
    static STRUCT_IF_C STT5151 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5151)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5151)");
    check_field_offset(lv, fa, 0, "STT5151.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5151");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5151");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5151, STT5151)
//============================================================================


struct  STT5161  {
  void *fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT5161) C1{ Fp Fs:3 Fs}



static void Test_STT5161()
{
  {
    init_simple_test("STT5161");
    static STRUCT_IF_C STT5161 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5161)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5161)");
    check_field_offset(lv, fa, 0, "STT5161.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5161");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5161");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5161, STT5161)
//============================================================================


struct  STT5171  {
  void *fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT5171) C1{ Fp Fi:3 Fs}



static void Test_STT5171()
{
  {
    init_simple_test("STT5171");
    static STRUCT_IF_C STT5171 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5171)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5171)");
    check_field_offset(lv, fa, 0, "STT5171.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5171");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5171");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5171, STT5171)
//============================================================================


struct  STT5181  {
  void *fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT5181) C1{ Fp FL:3 Fs}



static void Test_STT5181()
{
  {
    init_simple_test("STT5181");
    static STRUCT_IF_C STT5181 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5181)");
    check_field_offset(lv, fa, 0, "STT5181.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5181");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5181");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5181, STT5181)
//============================================================================


struct  STT5191  {
  void *fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT5191) C1{ Fp Fs:8 Fs}



static void Test_STT5191()
{
  {
    init_simple_test("STT5191");
    static STRUCT_IF_C STT5191 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5191)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5191)");
    check_field_offset(lv, fa, 0, "STT5191.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5191");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5191");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5191, STT5191)
//============================================================================


struct  STT5201  {
  void *fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT5201) C1{ Fp Fi:8 Fs}



static void Test_STT5201()
{
  {
    init_simple_test("STT5201");
    static STRUCT_IF_C STT5201 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5201)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5201)");
    check_field_offset(lv, fa, 0, "STT5201.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5201");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5201");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5201, STT5201)
//============================================================================


struct  STT5211  {
  void *fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT5211) C1{ Fp FL:8 Fs}



static void Test_STT5211()
{
  {
    init_simple_test("STT5211");
    static STRUCT_IF_C STT5211 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5211)");
    check_field_offset(lv, fa, 0, "STT5211.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5211");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5211");
    check_field_offset(lv, fb, ABISELECT(10,6), "STT5211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5211, STT5211)
//============================================================================


struct  STT5221  {
  void *fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT5221) C1{ Fp Fi:18 Fs}



static void Test_STT5221()
{
  {
    init_simple_test("STT5221");
    static STRUCT_IF_C STT5221 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5221)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5221)");
    check_field_offset(lv, fa, 0, "STT5221.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5221");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5221");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5221, STT5221)
//============================================================================


struct  STT5231  {
  void *fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT5231) C1{ Fp FL:18 Fs}



static void Test_STT5231()
{
  {
    init_simple_test("STT5231");
    static STRUCT_IF_C STT5231 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5231)");
    check_field_offset(lv, fa, 0, "STT5231.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5231");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5231");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5231, STT5231)
//============================================================================


struct  STT5241  {
  void *fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT5241) C1{ Fp FL:48 Fs}



static void Test_STT5241()
{
  {
    init_simple_test("STT5241");
    static STRUCT_IF_C STT5241 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5241)");
    check_field_offset(lv, fa, 0, "STT5241.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5241");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5241");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT5241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5241, STT5241)
//============================================================================


struct  STT512  {
  void *fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT512) C1{ Fp Fc:0 Fi}



static void Test_STT512()
{
  {
    init_simple_test("STT512");
    static STRUCT_IF_C STT512 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT512)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT512)");
    check_field_offset(lv, fa, 0, "STT512.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT512.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT512, STT512)
//============================================================================


struct  STT522  {
  void *fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT522) C1{ Fp Fs:0 Fi}



static void Test_STT522()
{
  {
    init_simple_test("STT522");
    static STRUCT_IF_C STT522 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT522)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT522)");
    check_field_offset(lv, fa, 0, "STT522.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT522.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT522, STT522)
//============================================================================


struct  STT532  {
  void *fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT532) C1{ Fp Fi:0 Fi}



static void Test_STT532()
{
  {
    init_simple_test("STT532");
    static STRUCT_IF_C STT532 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT532)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT532)");
    check_field_offset(lv, fa, 0, "STT532.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT532.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT532, STT532)
//============================================================================


struct  STT542  {
  void *fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT542) C1{ Fp FL:0 Fi}



static void Test_STT542()
{
  {
    init_simple_test("STT542");
    static STRUCT_IF_C STT542 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT542)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT542)");
    check_field_offset(lv, fa, 0, "STT542.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT542.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT542, STT542)
//============================================================================


struct  STT552  {
  void *fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT552) C1{ Fp Fc:3 Fi}



static void Test_STT552()
{
  {
    init_simple_test("STT552");
    static STRUCT_IF_C STT552 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT552)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT552)");
    check_field_offset(lv, fa, 0, "STT552.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT552.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT552, STT552)
//============================================================================


struct  STT562  {
  void *fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT562) C1{ Fp Fs:3 Fi}



static void Test_STT562()
{
  {
    init_simple_test("STT562");
    static STRUCT_IF_C STT562 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT562)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT562)");
    check_field_offset(lv, fa, 0, "STT562.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT562.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT562, STT562)
//============================================================================


struct  STT572  {
  void *fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT572) C1{ Fp Fi:3 Fi}



static void Test_STT572()
{
  {
    init_simple_test("STT572");
    static STRUCT_IF_C STT572 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT572)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT572)");
    check_field_offset(lv, fa, 0, "STT572.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT572.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT572, STT572)
//============================================================================


struct  STT582  {
  void *fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT582) C1{ Fp FL:3 Fi}



static void Test_STT582()
{
  {
    init_simple_test("STT582");
    static STRUCT_IF_C STT582 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT582)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT582)");
    check_field_offset(lv, fa, 0, "STT582.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT582.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT582, STT582)
//============================================================================


struct  STT592  {
  void *fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT592) C1{ Fp Fs:8 Fi}



static void Test_STT592()
{
  {
    init_simple_test("STT592");
    static STRUCT_IF_C STT592 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT592)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT592)");
    check_field_offset(lv, fa, 0, "STT592.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT592.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT592, STT592)
//============================================================================


struct  STT5102  {
  void *fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT5102) C1{ Fp Fi:8 Fi}



static void Test_STT5102()
{
  {
    init_simple_test("STT5102");
    static STRUCT_IF_C STT5102 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5102)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5102)");
    check_field_offset(lv, fa, 0, "STT5102.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5102, STT5102)
//============================================================================


struct  STT5112  {
  void *fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT5112) C1{ Fp FL:8 Fi}



static void Test_STT5112()
{
  {
    init_simple_test("STT5112");
    static STRUCT_IF_C STT5112 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5112)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5112)");
    check_field_offset(lv, fa, 0, "STT5112.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5112, STT5112)
//============================================================================


struct  STT5122  {
  void *fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT5122) C1{ Fp Fi:18 Fi}



static void Test_STT5122()
{
  {
    init_simple_test("STT5122");
    static STRUCT_IF_C STT5122 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5122)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5122)");
    check_field_offset(lv, fa, 0, "STT5122.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5122, STT5122)
//============================================================================


struct  STT5132  {
  void *fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT5132) C1{ Fp FL:18 Fi}



static void Test_STT5132()
{
  {
    init_simple_test("STT5132");
    static STRUCT_IF_C STT5132 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5132)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5132)");
    check_field_offset(lv, fa, 0, "STT5132.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5132, STT5132)
//============================================================================


struct  STT5142  {
  void *fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT5142) C1{ Fp FL:48 Fi}



static void Test_STT5142()
{
  {
    init_simple_test("STT5142");
    static STRUCT_IF_C STT5142 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5142)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5142)");
    check_field_offset(lv, fa, 0, "STT5142.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5142, STT5142)
//============================================================================


struct  STT5152  {
  void *fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT5152) C1{ Fp Fc:3 Fi}



static void Test_STT5152()
{
  {
    init_simple_test("STT5152");
    static STRUCT_IF_C STT5152 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5152)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5152)");
    check_field_offset(lv, fa, 0, "STT5152.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5152");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5152");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5152, STT5152)
//============================================================================


struct  STT5162  {
  void *fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT5162) C1{ Fp Fs:3 Fi}



static void Test_STT5162()
{
  {
    init_simple_test("STT5162");
    static STRUCT_IF_C STT5162 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5162)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5162)");
    check_field_offset(lv, fa, 0, "STT5162.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5162");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5162");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5162, STT5162)
//============================================================================


struct  STT5172  {
  void *fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT5172) C1{ Fp Fi:3 Fi}



static void Test_STT5172()
{
  {
    init_simple_test("STT5172");
    static STRUCT_IF_C STT5172 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5172)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5172)");
    check_field_offset(lv, fa, 0, "STT5172.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5172");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5172");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5172, STT5172)
//============================================================================


struct  STT5182  {
  void *fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT5182) C1{ Fp FL:3 Fi}



static void Test_STT5182()
{
  {
    init_simple_test("STT5182");
    static STRUCT_IF_C STT5182 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5182)");
    check_field_offset(lv, fa, 0, "STT5182.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5182");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5182");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5182, STT5182)
//============================================================================


struct  STT5192  {
  void *fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT5192) C1{ Fp Fs:8 Fi}



static void Test_STT5192()
{
  {
    init_simple_test("STT5192");
    static STRUCT_IF_C STT5192 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5192)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5192)");
    check_field_offset(lv, fa, 0, "STT5192.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5192");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5192");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5192, STT5192)
//============================================================================


struct  STT5202  {
  void *fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT5202) C1{ Fp Fi:8 Fi}



static void Test_STT5202()
{
  {
    init_simple_test("STT5202");
    static STRUCT_IF_C STT5202 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5202)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5202)");
    check_field_offset(lv, fa, 0, "STT5202.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5202");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5202");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5202, STT5202)
//============================================================================


struct  STT5212  {
  void *fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT5212) C1{ Fp FL:8 Fi}



static void Test_STT5212()
{
  {
    init_simple_test("STT5212");
    static STRUCT_IF_C STT5212 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5212)");
    check_field_offset(lv, fa, 0, "STT5212.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5212");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5212");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5212, STT5212)
//============================================================================


struct  STT5222  {
  void *fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT5222) C1{ Fp Fi:18 Fi}



static void Test_STT5222()
{
  {
    init_simple_test("STT5222");
    static STRUCT_IF_C STT5222 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5222)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5222)");
    check_field_offset(lv, fa, 0, "STT5222.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5222");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5222");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5222, STT5222)
//============================================================================


struct  STT5232  {
  void *fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT5232) C1{ Fp FL:18 Fi}



static void Test_STT5232()
{
  {
    init_simple_test("STT5232");
    static STRUCT_IF_C STT5232 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5232)");
    check_field_offset(lv, fa, 0, "STT5232.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5232");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5232");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5232, STT5232)
//============================================================================


struct  STT5242  {
  void *fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT5242) C1{ Fp FL:48 Fi}



static void Test_STT5242()
{
  {
    init_simple_test("STT5242");
    static STRUCT_IF_C STT5242 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5242)");
    check_field_offset(lv, fa, 0, "STT5242.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5242");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5242");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5242, STT5242)
//============================================================================


struct  STT513  {
  void *fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT513) C1{ Fp Fc:0 Fl}



static void Test_STT513()
{
  {
    init_simple_test("STT513");
    static STRUCT_IF_C STT513 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT513)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT513)");
    check_field_offset(lv, fa, 0, "STT513.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT513.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT513, STT513)
//============================================================================


struct  STT523  {
  void *fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT523) C1{ Fp Fs:0 Fl}



static void Test_STT523()
{
  {
    init_simple_test("STT523");
    static STRUCT_IF_C STT523 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT523)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT523)");
    check_field_offset(lv, fa, 0, "STT523.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT523.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT523, STT523)
//============================================================================


struct  STT533  {
  void *fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT533) C1{ Fp Fi:0 Fl}



static void Test_STT533()
{
  {
    init_simple_test("STT533");
    static STRUCT_IF_C STT533 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT533)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT533)");
    check_field_offset(lv, fa, 0, "STT533.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT533.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT533, STT533)
//============================================================================


struct  STT543  {
  void *fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT543) C1{ Fp FL:0 Fl}



static void Test_STT543()
{
  {
    init_simple_test("STT543");
    static STRUCT_IF_C STT543 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT543)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT543)");
    check_field_offset(lv, fa, 0, "STT543.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT543.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT543, STT543)
//============================================================================


struct  STT553  {
  void *fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT553) C1{ Fp Fc:3 Fl}



static void Test_STT553()
{
  {
    init_simple_test("STT553");
    static STRUCT_IF_C STT553 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT553)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT553)");
    check_field_offset(lv, fa, 0, "STT553.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT553.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT553, STT553)
//============================================================================


struct  STT563  {
  void *fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT563) C1{ Fp Fs:3 Fl}



static void Test_STT563()
{
  {
    init_simple_test("STT563");
    static STRUCT_IF_C STT563 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT563)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT563)");
    check_field_offset(lv, fa, 0, "STT563.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT563.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT563, STT563)
//============================================================================


struct  STT573  {
  void *fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT573) C1{ Fp Fi:3 Fl}



static void Test_STT573()
{
  {
    init_simple_test("STT573");
    static STRUCT_IF_C STT573 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT573)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT573)");
    check_field_offset(lv, fa, 0, "STT573.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT573.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT573, STT573)
//============================================================================


struct  STT583  {
  void *fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT583) C1{ Fp FL:3 Fl}



static void Test_STT583()
{
  {
    init_simple_test("STT583");
    static STRUCT_IF_C STT583 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT583)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT583)");
    check_field_offset(lv, fa, 0, "STT583.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT583.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT583, STT583)
//============================================================================


struct  STT593  {
  void *fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT593) C1{ Fp Fs:8 Fl}



static void Test_STT593()
{
  {
    init_simple_test("STT593");
    static STRUCT_IF_C STT593 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT593)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT593)");
    check_field_offset(lv, fa, 0, "STT593.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT593.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT593, STT593)
//============================================================================


struct  STT5103  {
  void *fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT5103) C1{ Fp Fi:8 Fl}



static void Test_STT5103()
{
  {
    init_simple_test("STT5103");
    static STRUCT_IF_C STT5103 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5103)");
    check_field_offset(lv, fa, 0, "STT5103.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5103, STT5103)
//============================================================================


struct  STT5113  {
  void *fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT5113) C1{ Fp FL:8 Fl}



static void Test_STT5113()
{
  {
    init_simple_test("STT5113");
    static STRUCT_IF_C STT5113 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5113)");
    check_field_offset(lv, fa, 0, "STT5113.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5113, STT5113)
//============================================================================


struct  STT5123  {
  void *fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT5123) C1{ Fp Fi:18 Fl}



static void Test_STT5123()
{
  {
    init_simple_test("STT5123");
    static STRUCT_IF_C STT5123 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5123)");
    check_field_offset(lv, fa, 0, "STT5123.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5123, STT5123)
//============================================================================


struct  STT5133  {
  void *fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT5133) C1{ Fp FL:18 Fl}



static void Test_STT5133()
{
  {
    init_simple_test("STT5133");
    static STRUCT_IF_C STT5133 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5133)");
    check_field_offset(lv, fa, 0, "STT5133.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5133, STT5133)
//============================================================================


struct  STT5143  {
  void *fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT5143) C1{ Fp FL:48 Fl}



static void Test_STT5143()
{
  {
    init_simple_test("STT5143");
    static STRUCT_IF_C STT5143 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5143)");
    check_field_offset(lv, fa, 0, "STT5143.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5143, STT5143)
//============================================================================


struct  STT5153  {
  void *fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT5153) C1{ Fp Fc:3 Fl}



static void Test_STT5153()
{
  {
    init_simple_test("STT5153");
    static STRUCT_IF_C STT5153 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5153)");
    check_field_offset(lv, fa, 0, "STT5153.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5153");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5153");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5153, STT5153)
//============================================================================


struct  STT5163  {
  void *fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT5163) C1{ Fp Fs:3 Fl}



static void Test_STT5163()
{
  {
    init_simple_test("STT5163");
    static STRUCT_IF_C STT5163 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5163)");
    check_field_offset(lv, fa, 0, "STT5163.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5163");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5163");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5163, STT5163)
//============================================================================


struct  STT5173  {
  void *fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT5173) C1{ Fp Fi:3 Fl}



static void Test_STT5173()
{
  {
    init_simple_test("STT5173");
    static STRUCT_IF_C STT5173 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5173)");
    check_field_offset(lv, fa, 0, "STT5173.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5173");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5173");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5173, STT5173)
//============================================================================


struct  STT5183  {
  void *fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT5183) C1{ Fp FL:3 Fl}



static void Test_STT5183()
{
  {
    init_simple_test("STT5183");
    static STRUCT_IF_C STT5183 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5183)");
    check_field_offset(lv, fa, 0, "STT5183.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5183");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5183");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5183, STT5183)
//============================================================================


struct  STT5193  {
  void *fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT5193) C1{ Fp Fs:8 Fl}



static void Test_STT5193()
{
  {
    init_simple_test("STT5193");
    static STRUCT_IF_C STT5193 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5193)");
    check_field_offset(lv, fa, 0, "STT5193.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5193");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5193");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5193, STT5193)
//============================================================================


struct  STT5203  {
  void *fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT5203) C1{ Fp Fi:8 Fl}



static void Test_STT5203()
{
  {
    init_simple_test("STT5203");
    static STRUCT_IF_C STT5203 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5203)");
    check_field_offset(lv, fa, 0, "STT5203.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5203");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5203");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5203, STT5203)
//============================================================================


struct  STT5213  {
  void *fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT5213) C1{ Fp FL:8 Fl}



static void Test_STT5213()
{
  {
    init_simple_test("STT5213");
    static STRUCT_IF_C STT5213 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5213)");
    check_field_offset(lv, fa, 0, "STT5213.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5213");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5213");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5213, STT5213)
//============================================================================


struct  STT5223  {
  void *fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT5223) C1{ Fp Fi:18 Fl}



static void Test_STT5223()
{
  {
    init_simple_test("STT5223");
    static STRUCT_IF_C STT5223 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5223)");
    check_field_offset(lv, fa, 0, "STT5223.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5223");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5223");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5223, STT5223)
//============================================================================


struct  STT5233  {
  void *fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT5233) C1{ Fp FL:18 Fl}



static void Test_STT5233()
{
  {
    init_simple_test("STT5233");
    static STRUCT_IF_C STT5233 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5233)");
    check_field_offset(lv, fa, 0, "STT5233.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5233");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5233");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5233, STT5233)
//============================================================================


struct  STT5243  {
  void *fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT5243) C1{ Fp FL:48 Fl}



static void Test_STT5243()
{
  {
    init_simple_test("STT5243");
    static STRUCT_IF_C STT5243 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5243)");
    check_field_offset(lv, fa, 0, "STT5243.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5243");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5243");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5243, STT5243)
//============================================================================


struct  STT514  {
  void *fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT514) C1{ Fp Fc:0 FL}



static void Test_STT514()
{
  {
    init_simple_test("STT514");
    static STRUCT_IF_C STT514 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT514)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT514)");
    check_field_offset(lv, fa, 0, "STT514.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT514.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT514, STT514)
//============================================================================


struct  STT524  {
  void *fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT524) C1{ Fp Fs:0 FL}



static void Test_STT524()
{
  {
    init_simple_test("STT524");
    static STRUCT_IF_C STT524 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT524)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT524)");
    check_field_offset(lv, fa, 0, "STT524.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT524.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT524, STT524)
//============================================================================


struct  STT534  {
  void *fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT534) C1{ Fp Fi:0 FL}



static void Test_STT534()
{
  {
    init_simple_test("STT534");
    static STRUCT_IF_C STT534 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT534)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT534)");
    check_field_offset(lv, fa, 0, "STT534.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT534.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT534, STT534)
//============================================================================


struct  STT544  {
  void *fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT544) C1{ Fp FL:0 FL}



static void Test_STT544()
{
  {
    init_simple_test("STT544");
    static STRUCT_IF_C STT544 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT544)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT544)");
    check_field_offset(lv, fa, 0, "STT544.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT544.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT544, STT544)
//============================================================================


struct  STT554  {
  void *fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT554) C1{ Fp Fc:3 FL}



static void Test_STT554()
{
  {
    init_simple_test("STT554");
    static STRUCT_IF_C STT554 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT554)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT554)");
    check_field_offset(lv, fa, 0, "STT554.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT554.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT554, STT554)
//============================================================================


struct  STT564  {
  void *fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT564) C1{ Fp Fs:3 FL}



static void Test_STT564()
{
  {
    init_simple_test("STT564");
    static STRUCT_IF_C STT564 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT564)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT564)");
    check_field_offset(lv, fa, 0, "STT564.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT564.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT564, STT564)
//============================================================================


struct  STT574  {
  void *fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT574) C1{ Fp Fi:3 FL}



static void Test_STT574()
{
  {
    init_simple_test("STT574");
    static STRUCT_IF_C STT574 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT574)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT574)");
    check_field_offset(lv, fa, 0, "STT574.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT574.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT574, STT574)
//============================================================================


struct  STT584  {
  void *fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT584) C1{ Fp FL:3 FL}



static void Test_STT584()
{
  {
    init_simple_test("STT584");
    static STRUCT_IF_C STT584 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT584)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT584)");
    check_field_offset(lv, fa, 0, "STT584.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT584.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT584, STT584)
//============================================================================


struct  STT594  {
  void *fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT594) C1{ Fp Fs:8 FL}



static void Test_STT594()
{
  {
    init_simple_test("STT594");
    static STRUCT_IF_C STT594 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT594)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT594)");
    check_field_offset(lv, fa, 0, "STT594.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT594.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT594, STT594)
//============================================================================


struct  STT5104  {
  void *fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT5104) C1{ Fp Fi:8 FL}



static void Test_STT5104()
{
  {
    init_simple_test("STT5104");
    static STRUCT_IF_C STT5104 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5104)");
    check_field_offset(lv, fa, 0, "STT5104.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5104, STT5104)
//============================================================================


struct  STT5114  {
  void *fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT5114) C1{ Fp FL:8 FL}



static void Test_STT5114()
{
  {
    init_simple_test("STT5114");
    static STRUCT_IF_C STT5114 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5114)");
    check_field_offset(lv, fa, 0, "STT5114.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5114, STT5114)
//============================================================================


struct  STT5124  {
  void *fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT5124) C1{ Fp Fi:18 FL}



static void Test_STT5124()
{
  {
    init_simple_test("STT5124");
    static STRUCT_IF_C STT5124 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5124)");
    check_field_offset(lv, fa, 0, "STT5124.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5124, STT5124)
//============================================================================


struct  STT5134  {
  void *fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT5134) C1{ Fp FL:18 FL}



static void Test_STT5134()
{
  {
    init_simple_test("STT5134");
    static STRUCT_IF_C STT5134 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5134)");
    check_field_offset(lv, fa, 0, "STT5134.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5134, STT5134)
//============================================================================


struct  STT5144  {
  void *fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT5144) C1{ Fp FL:48 FL}



static void Test_STT5144()
{
  {
    init_simple_test("STT5144");
    static STRUCT_IF_C STT5144 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT5144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5144)");
    check_field_offset(lv, fa, 0, "STT5144.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5144, STT5144)
//============================================================================


struct  STT5154  {
  void *fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT5154) C1{ Fp Fc:3 FL}



static void Test_STT5154()
{
  {
    init_simple_test("STT5154");
    static STRUCT_IF_C STT5154 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5154)");
    check_field_offset(lv, fa, 0, "STT5154.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5154");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5154");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5154, STT5154)
//============================================================================


struct  STT5164  {
  void *fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT5164) C1{ Fp Fs:3 FL}



static void Test_STT5164()
{
  {
    init_simple_test("STT5164");
    static STRUCT_IF_C STT5164 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5164)");
    check_field_offset(lv, fa, 0, "STT5164.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5164");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5164");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5164, STT5164)
//============================================================================


struct  STT5174  {
  void *fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT5174) C1{ Fp Fi:3 FL}



static void Test_STT5174()
{
  {
    init_simple_test("STT5174");
    static STRUCT_IF_C STT5174 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5174)");
    check_field_offset(lv, fa, 0, "STT5174.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5174");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5174");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5174, STT5174)
//============================================================================


struct  STT5184  {
  void *fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT5184) C1{ Fp FL:3 FL}



static void Test_STT5184()
{
  {
    init_simple_test("STT5184");
    static STRUCT_IF_C STT5184 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5184)");
    check_field_offset(lv, fa, 0, "STT5184.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5184");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5184");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5184, STT5184)
//============================================================================


struct  STT5194  {
  void *fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT5194) C1{ Fp Fs:8 FL}



static void Test_STT5194()
{
  {
    init_simple_test("STT5194");
    static STRUCT_IF_C STT5194 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5194)");
    check_field_offset(lv, fa, 0, "STT5194.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5194");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5194");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5194, STT5194)
//============================================================================


struct  STT5204  {
  void *fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT5204) C1{ Fp Fi:8 FL}



static void Test_STT5204()
{
  {
    init_simple_test("STT5204");
    static STRUCT_IF_C STT5204 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5204)");
    check_field_offset(lv, fa, 0, "STT5204.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5204");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5204");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5204, STT5204)
//============================================================================


struct  STT5214  {
  void *fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT5214) C1{ Fp FL:8 FL}



static void Test_STT5214()
{
  {
    init_simple_test("STT5214");
    static STRUCT_IF_C STT5214 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5214)");
    check_field_offset(lv, fa, 0, "STT5214.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5214");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5214");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5214, STT5214)
//============================================================================


struct  STT5224  {
  void *fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT5224) C1{ Fp Fi:18 FL}



static void Test_STT5224()
{
  {
    init_simple_test("STT5224");
    static STRUCT_IF_C STT5224 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5224)");
    check_field_offset(lv, fa, 0, "STT5224.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5224");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5224");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5224, STT5224)
//============================================================================


struct  STT5234  {
  void *fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT5234) C1{ Fp FL:18 FL}



static void Test_STT5234()
{
  {
    init_simple_test("STT5234");
    static STRUCT_IF_C STT5234 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5234)");
    check_field_offset(lv, fa, 0, "STT5234.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5234");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5234");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5234, STT5234)
//============================================================================


struct  STT5244  {
  void *fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT5244) C1{ Fp FL:48 FL}



static void Test_STT5244()
{
  {
    init_simple_test("STT5244");
    static STRUCT_IF_C STT5244 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT5244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5244)");
    check_field_offset(lv, fa, 0, "STT5244.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5244");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5244");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5244, STT5244)
//============================================================================


struct  STT515  {
  void *fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT515) C1{ Fp Fc:0 Fp}



static void Test_STT515()
{
  {
    init_simple_test("STT515");
    static STRUCT_IF_C STT515 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT515)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT515)");
    check_field_offset(lv, fa, 0, "STT515.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT515.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT515, STT515)
//============================================================================


struct  STT525  {
  void *fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT525) C1{ Fp Fs:0 Fp}



static void Test_STT525()
{
  {
    init_simple_test("STT525");
    static STRUCT_IF_C STT525 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT525)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT525)");
    check_field_offset(lv, fa, 0, "STT525.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT525.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT525, STT525)
//============================================================================


struct  STT535  {
  void *fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT535) C1{ Fp Fi:0 Fp}



static void Test_STT535()
{
  {
    init_simple_test("STT535");
    static STRUCT_IF_C STT535 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT535)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT535)");
    check_field_offset(lv, fa, 0, "STT535.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT535.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT535, STT535)
//============================================================================


struct  STT545  {
  void *fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT545) C1{ Fp FL:0 Fp}



static void Test_STT545()
{
  {
    init_simple_test("STT545");
    static STRUCT_IF_C STT545 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT545)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT545)");
    check_field_offset(lv, fa, 0, "STT545.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT545.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT545, STT545)
//============================================================================


struct  STT555  {
  void *fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT555) C1{ Fp Fc:3 Fp}



static void Test_STT555()
{
  {
    init_simple_test("STT555");
    static STRUCT_IF_C STT555 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT555)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT555)");
    check_field_offset(lv, fa, 0, "STT555.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT555.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT555, STT555)
//============================================================================


struct  STT565  {
  void *fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT565) C1{ Fp Fs:3 Fp}



static void Test_STT565()
{
  {
    init_simple_test("STT565");
    static STRUCT_IF_C STT565 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT565)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT565)");
    check_field_offset(lv, fa, 0, "STT565.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT565.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT565, STT565)
//============================================================================


struct  STT575  {
  void *fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT575) C1{ Fp Fi:3 Fp}



static void Test_STT575()
{
  {
    init_simple_test("STT575");
    static STRUCT_IF_C STT575 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT575)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT575)");
    check_field_offset(lv, fa, 0, "STT575.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT575.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT575, STT575)
//============================================================================


struct  STT585  {
  void *fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT585) C1{ Fp FL:3 Fp}



static void Test_STT585()
{
  {
    init_simple_test("STT585");
    static STRUCT_IF_C STT585 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT585)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT585)");
    check_field_offset(lv, fa, 0, "STT585.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT585.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT585, STT585)
//============================================================================


struct  STT595  {
  void *fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT595) C1{ Fp Fs:8 Fp}



static void Test_STT595()
{
  {
    init_simple_test("STT595");
    static STRUCT_IF_C STT595 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT595)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT595)");
    check_field_offset(lv, fa, 0, "STT595.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT595.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT595, STT595)
//============================================================================


struct  STT5105  {
  void *fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT5105) C1{ Fp Fi:8 Fp}



static void Test_STT5105()
{
  {
    init_simple_test("STT5105");
    static STRUCT_IF_C STT5105 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5105)");
    check_field_offset(lv, fa, 0, "STT5105.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5105, STT5105)
//============================================================================


struct  STT5115  {
  void *fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT5115) C1{ Fp FL:8 Fp}



static void Test_STT5115()
{
  {
    init_simple_test("STT5115");
    static STRUCT_IF_C STT5115 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5115)");
    check_field_offset(lv, fa, 0, "STT5115.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5115, STT5115)
//============================================================================


struct  STT5125  {
  void *fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT5125) C1{ Fp Fi:18 Fp}



static void Test_STT5125()
{
  {
    init_simple_test("STT5125");
    static STRUCT_IF_C STT5125 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5125)");
    check_field_offset(lv, fa, 0, "STT5125.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5125, STT5125)
//============================================================================


struct  STT5135  {
  void *fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT5135) C1{ Fp FL:18 Fp}



static void Test_STT5135()
{
  {
    init_simple_test("STT5135");
    static STRUCT_IF_C STT5135 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5135)");
    check_field_offset(lv, fa, 0, "STT5135.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5135, STT5135)
//============================================================================


struct  STT5145  {
  void *fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT5145) C1{ Fp FL:48 Fp}



static void Test_STT5145()
{
  {
    init_simple_test("STT5145");
    static STRUCT_IF_C STT5145 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5145)");
    check_field_offset(lv, fa, 0, "STT5145.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5145, STT5145)
//============================================================================


struct  STT5155  {
  void *fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT5155) C1{ Fp Fc:3 Fp}



static void Test_STT5155()
{
  {
    init_simple_test("STT5155");
    static STRUCT_IF_C STT5155 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5155)");
    check_field_offset(lv, fa, 0, "STT5155.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5155");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5155");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5155, STT5155)
//============================================================================


struct  STT5165  {
  void *fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT5165) C1{ Fp Fs:3 Fp}



static void Test_STT5165()
{
  {
    init_simple_test("STT5165");
    static STRUCT_IF_C STT5165 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5165)");
    check_field_offset(lv, fa, 0, "STT5165.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5165");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5165");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5165, STT5165)
//============================================================================


struct  STT5175  {
  void *fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT5175) C1{ Fp Fi:3 Fp}



static void Test_STT5175()
{
  {
    init_simple_test("STT5175");
    static STRUCT_IF_C STT5175 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5175)");
    check_field_offset(lv, fa, 0, "STT5175.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5175");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5175");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5175, STT5175)
//============================================================================


struct  STT5185  {
  void *fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT5185) C1{ Fp FL:3 Fp}



static void Test_STT5185()
{
  {
    init_simple_test("STT5185");
    static STRUCT_IF_C STT5185 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5185)");
    check_field_offset(lv, fa, 0, "STT5185.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5185");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5185");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5185, STT5185)
//============================================================================


struct  STT5195  {
  void *fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT5195) C1{ Fp Fs:8 Fp}



static void Test_STT5195()
{
  {
    init_simple_test("STT5195");
    static STRUCT_IF_C STT5195 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5195)");
    check_field_offset(lv, fa, 0, "STT5195.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5195");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5195");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5195, STT5195)
//============================================================================


struct  STT5205  {
  void *fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT5205) C1{ Fp Fi:8 Fp}



static void Test_STT5205()
{
  {
    init_simple_test("STT5205");
    static STRUCT_IF_C STT5205 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5205)");
    check_field_offset(lv, fa, 0, "STT5205.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5205");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5205");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5205, STT5205)
//============================================================================


struct  STT5215  {
  void *fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT5215) C1{ Fp FL:8 Fp}



static void Test_STT5215()
{
  {
    init_simple_test("STT5215");
    static STRUCT_IF_C STT5215 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5215)");
    check_field_offset(lv, fa, 0, "STT5215.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5215");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5215");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5215, STT5215)
//============================================================================


struct  STT5225  {
  void *fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT5225) C1{ Fp Fi:18 Fp}



static void Test_STT5225()
{
  {
    init_simple_test("STT5225");
    static STRUCT_IF_C STT5225 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5225)");
    check_field_offset(lv, fa, 0, "STT5225.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5225");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5225");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5225, STT5225)
//============================================================================


struct  STT5235  {
  void *fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT5235) C1{ Fp FL:18 Fp}



static void Test_STT5235()
{
  {
    init_simple_test("STT5235");
    static STRUCT_IF_C STT5235 lv;
    check2(sizeof(lv), ABISELECT(24,12), "sizeof(STT5235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5235)");
    check_field_offset(lv, fa, 0, "STT5235.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5235");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5235");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5235, STT5235)
//============================================================================


struct  STT5245  {
  void *fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT5245) C1{ Fp FL:48 Fp}



static void Test_STT5245()
{
  {
    init_simple_test("STT5245");
    static STRUCT_IF_C STT5245 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5245)");
    check_field_offset(lv, fa, 0, "STT5245.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5245");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5245");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5245, STT5245)
//============================================================================


struct  STT516  {
  void *fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT516) C1{ Fp Fc:0 Fi}



static void Test_STT516()
{
  {
    init_simple_test("STT516");
    static STRUCT_IF_C STT516 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT516)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT516)");
    check_field_offset(lv, fa, 0, "STT516.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT516.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT516, STT516)
//============================================================================


struct  STT526  {
  void *fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT526) C1{ Fp Fs:0 Fi}



static void Test_STT526()
{
  {
    init_simple_test("STT526");
    static STRUCT_IF_C STT526 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT526)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT526)");
    check_field_offset(lv, fa, 0, "STT526.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT526.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT526, STT526)
//============================================================================


struct  STT536  {
  void *fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT536) C1{ Fp Fi:0 Fi}



static void Test_STT536()
{
  {
    init_simple_test("STT536");
    static STRUCT_IF_C STT536 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT536)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT536)");
    check_field_offset(lv, fa, 0, "STT536.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT536.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT536, STT536)
//============================================================================


struct  STT546  {
  void *fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT546) C1{ Fp FL:0 Fi}



static void Test_STT546()
{
  {
    init_simple_test("STT546");
    static STRUCT_IF_C STT546 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT546)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT546)");
    check_field_offset(lv, fa, 0, "STT546.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT546.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT546, STT546)
//============================================================================


struct  STT556  {
  void *fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT556) C1{ Fp Fc:3 Fi}



static void Test_STT556()
{
  {
    init_simple_test("STT556");
    static STRUCT_IF_C STT556 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT556)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT556)");
    check_field_offset(lv, fa, 0, "STT556.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT556.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT556, STT556)
//============================================================================


struct  STT566  {
  void *fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT566) C1{ Fp Fs:3 Fi}



static void Test_STT566()
{
  {
    init_simple_test("STT566");
    static STRUCT_IF_C STT566 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT566)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT566)");
    check_field_offset(lv, fa, 0, "STT566.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT566.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT566, STT566)
//============================================================================


struct  STT576  {
  void *fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT576) C1{ Fp Fi:3 Fi}



static void Test_STT576()
{
  {
    init_simple_test("STT576");
    static STRUCT_IF_C STT576 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT576)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT576)");
    check_field_offset(lv, fa, 0, "STT576.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT576.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT576, STT576)
//============================================================================


struct  STT586  {
  void *fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT586) C1{ Fp FL:3 Fi}



static void Test_STT586()
{
  {
    init_simple_test("STT586");
    static STRUCT_IF_C STT586 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT586)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT586)");
    check_field_offset(lv, fa, 0, "STT586.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT586.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT586, STT586)
//============================================================================


struct  STT596  {
  void *fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT596) C1{ Fp Fs:8 Fi}



static void Test_STT596()
{
  {
    init_simple_test("STT596");
    static STRUCT_IF_C STT596 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT596)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT596)");
    check_field_offset(lv, fa, 0, "STT596.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT596.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT596, STT596)
//============================================================================


struct  STT5106  {
  void *fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT5106) C1{ Fp Fi:8 Fi}



static void Test_STT5106()
{
  {
    init_simple_test("STT5106");
    static STRUCT_IF_C STT5106 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5106)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5106)");
    check_field_offset(lv, fa, 0, "STT5106.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5106, STT5106)
//============================================================================


struct  STT5116  {
  void *fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT5116) C1{ Fp FL:8 Fi}



static void Test_STT5116()
{
  {
    init_simple_test("STT5116");
    static STRUCT_IF_C STT5116 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5116)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5116)");
    check_field_offset(lv, fa, 0, "STT5116.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5116, STT5116)
//============================================================================


struct  STT5126  {
  void *fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT5126) C1{ Fp Fi:18 Fi}



static void Test_STT5126()
{
  {
    init_simple_test("STT5126");
    static STRUCT_IF_C STT5126 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5126)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5126)");
    check_field_offset(lv, fa, 0, "STT5126.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5126, STT5126)
//============================================================================


struct  STT5136  {
  void *fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT5136) C1{ Fp FL:18 Fi}



static void Test_STT5136()
{
  {
    init_simple_test("STT5136");
    static STRUCT_IF_C STT5136 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5136)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5136)");
    check_field_offset(lv, fa, 0, "STT5136.fa");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5136, STT5136)
//============================================================================


struct  STT5146  {
  void *fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT5146) C1{ Fp FL:48 Fi}



static void Test_STT5146()
{
  {
    init_simple_test("STT5146");
    static STRUCT_IF_C STT5146 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5146)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5146)");
    check_field_offset(lv, fa, 0, "STT5146.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5146, STT5146)
//============================================================================


struct  STT5156  {
  void *fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT5156) C1{ Fp Fc:3 Fi}



static void Test_STT5156()
{
  {
    init_simple_test("STT5156");
    static STRUCT_IF_C STT5156 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5156)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5156)");
    check_field_offset(lv, fa, 0, "STT5156.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5156");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5156");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5156, STT5156)
//============================================================================


struct  STT5166  {
  void *fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT5166) C1{ Fp Fs:3 Fi}



static void Test_STT5166()
{
  {
    init_simple_test("STT5166");
    static STRUCT_IF_C STT5166 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5166)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5166)");
    check_field_offset(lv, fa, 0, "STT5166.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5166");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5166");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5166, STT5166)
//============================================================================


struct  STT5176  {
  void *fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT5176) C1{ Fp Fi:3 Fi}



static void Test_STT5176()
{
  {
    init_simple_test("STT5176");
    static STRUCT_IF_C STT5176 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5176)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5176)");
    check_field_offset(lv, fa, 0, "STT5176.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5176");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5176");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5176, STT5176)
//============================================================================


struct  STT5186  {
  void *fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT5186) C1{ Fp FL:3 Fi}



static void Test_STT5186()
{
  {
    init_simple_test("STT5186");
    static STRUCT_IF_C STT5186 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5186)");
    check_field_offset(lv, fa, 0, "STT5186.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5186");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5186");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5186, STT5186)
//============================================================================


struct  STT5196  {
  void *fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT5196) C1{ Fp Fs:8 Fi}



static void Test_STT5196()
{
  {
    init_simple_test("STT5196");
    static STRUCT_IF_C STT5196 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5196)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5196)");
    check_field_offset(lv, fa, 0, "STT5196.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5196");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5196");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5196, STT5196)
//============================================================================


struct  STT5206  {
  void *fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT5206) C1{ Fp Fi:8 Fi}



static void Test_STT5206()
{
  {
    init_simple_test("STT5206");
    static STRUCT_IF_C STT5206 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5206)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5206)");
    check_field_offset(lv, fa, 0, "STT5206.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5206");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5206");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5206, STT5206)
//============================================================================


struct  STT5216  {
  void *fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT5216) C1{ Fp FL:8 Fi}



static void Test_STT5216()
{
  {
    init_simple_test("STT5216");
    static STRUCT_IF_C STT5216 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5216)");
    check_field_offset(lv, fa, 0, "STT5216.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5216");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5216");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5216, STT5216)
//============================================================================


struct  STT5226  {
  void *fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT5226) C1{ Fp Fi:18 Fi}



static void Test_STT5226()
{
  {
    init_simple_test("STT5226");
    static STRUCT_IF_C STT5226 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5226)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5226)");
    check_field_offset(lv, fa, 0, "STT5226.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5226");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5226");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5226, STT5226)
//============================================================================


struct  STT5236  {
  void *fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT5236) C1{ Fp FL:18 Fi}



static void Test_STT5236()
{
  {
    init_simple_test("STT5236");
    static STRUCT_IF_C STT5236 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5236)");
    check_field_offset(lv, fa, 0, "STT5236.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5236");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5236");
    check_field_offset(lv, fb, ABISELECT(12,8), "STT5236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5236, STT5236)
//============================================================================


struct  STT5246  {
  void *fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT5246) C1{ Fp FL:48 Fi}



static void Test_STT5246()
{
  {
    init_simple_test("STT5246");
    static STRUCT_IF_C STT5246 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5246)");
    check_field_offset(lv, fa, 0, "STT5246.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5246");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5246");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5246, STT5246)
//============================================================================


struct  STT517  {
  void *fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT517) C1{ Fp Fc:0 FL}



static void Test_STT517()
{
  {
    init_simple_test("STT517");
    static STRUCT_IF_C STT517 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT517)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT517)");
    check_field_offset(lv, fa, 0, "STT517.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT517.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT517, STT517)
//============================================================================


struct  STT527  {
  void *fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT527) C1{ Fp Fs:0 FL}



static void Test_STT527()
{
  {
    init_simple_test("STT527");
    static STRUCT_IF_C STT527 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT527)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT527)");
    check_field_offset(lv, fa, 0, "STT527.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT527.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT527, STT527)
//============================================================================


struct  STT537  {
  void *fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT537) C1{ Fp Fi:0 FL}



static void Test_STT537()
{
  {
    init_simple_test("STT537");
    static STRUCT_IF_C STT537 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT537)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT537)");
    check_field_offset(lv, fa, 0, "STT537.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT537.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT537, STT537)
//============================================================================


struct  STT547  {
  void *fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT547) C1{ Fp FL:0 FL}



static void Test_STT547()
{
  {
    init_simple_test("STT547");
    static STRUCT_IF_C STT547 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT547)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT547)");
    check_field_offset(lv, fa, 0, "STT547.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT547.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT547, STT547)
//============================================================================


struct  STT557  {
  void *fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT557) C1{ Fp Fc:3 FL}



static void Test_STT557()
{
  {
    init_simple_test("STT557");
    static STRUCT_IF_C STT557 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT557)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT557)");
    check_field_offset(lv, fa, 0, "STT557.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT557.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT557, STT557)
//============================================================================


struct  STT567  {
  void *fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT567) C1{ Fp Fs:3 FL}



static void Test_STT567()
{
  {
    init_simple_test("STT567");
    static STRUCT_IF_C STT567 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT567)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT567)");
    check_field_offset(lv, fa, 0, "STT567.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT567.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT567, STT567)
//============================================================================


struct  STT577  {
  void *fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT577) C1{ Fp Fi:3 FL}



static void Test_STT577()
{
  {
    init_simple_test("STT577");
    static STRUCT_IF_C STT577 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT577)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT577)");
    check_field_offset(lv, fa, 0, "STT577.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT577.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT577, STT577)
//============================================================================


struct  STT587  {
  void *fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT587) C1{ Fp FL:3 FL}



static void Test_STT587()
{
  {
    init_simple_test("STT587");
    static STRUCT_IF_C STT587 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT587)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT587)");
    check_field_offset(lv, fa, 0, "STT587.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT587.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT587, STT587)
//============================================================================


struct  STT597  {
  void *fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT597) C1{ Fp Fs:8 FL}



static void Test_STT597()
{
  {
    init_simple_test("STT597");
    static STRUCT_IF_C STT597 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT597)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT597)");
    check_field_offset(lv, fa, 0, "STT597.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT597.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT597, STT597)
//============================================================================


struct  STT5107  {
  void *fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT5107) C1{ Fp Fi:8 FL}



static void Test_STT5107()
{
  {
    init_simple_test("STT5107");
    static STRUCT_IF_C STT5107 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5107)");
    check_field_offset(lv, fa, 0, "STT5107.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5107, STT5107)
//============================================================================


struct  STT5117  {
  void *fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT5117) C1{ Fp FL:8 FL}



static void Test_STT5117()
{
  {
    init_simple_test("STT5117");
    static STRUCT_IF_C STT5117 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5117)");
    check_field_offset(lv, fa, 0, "STT5117.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5117, STT5117)
//============================================================================


struct  STT5127  {
  void *fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT5127) C1{ Fp Fi:18 FL}



static void Test_STT5127()
{
  {
    init_simple_test("STT5127");
    static STRUCT_IF_C STT5127 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5127)");
    check_field_offset(lv, fa, 0, "STT5127.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5127, STT5127)
//============================================================================


struct  STT5137  {
  void *fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT5137) C1{ Fp FL:18 FL}



static void Test_STT5137()
{
  {
    init_simple_test("STT5137");
    static STRUCT_IF_C STT5137 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5137)");
    check_field_offset(lv, fa, 0, "STT5137.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5137, STT5137)
//============================================================================


struct  STT5147  {
  void *fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT5147) C1{ Fp FL:48 FL}



static void Test_STT5147()
{
  {
    init_simple_test("STT5147");
    static STRUCT_IF_C STT5147 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT5147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5147)");
    check_field_offset(lv, fa, 0, "STT5147.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5147, STT5147)
//============================================================================


struct  STT5157  {
  void *fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT5157) C1{ Fp Fc:3 FL}



static void Test_STT5157()
{
  {
    init_simple_test("STT5157");
    static STRUCT_IF_C STT5157 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5157)");
    check_field_offset(lv, fa, 0, "STT5157.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5157");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5157");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5157, STT5157)
//============================================================================


struct  STT5167  {
  void *fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT5167) C1{ Fp Fs:3 FL}



static void Test_STT5167()
{
  {
    init_simple_test("STT5167");
    static STRUCT_IF_C STT5167 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5167)");
    check_field_offset(lv, fa, 0, "STT5167.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5167");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5167");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5167, STT5167)
//============================================================================


struct  STT5177  {
  void *fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT5177) C1{ Fp Fi:3 FL}



static void Test_STT5177()
{
  {
    init_simple_test("STT5177");
    static STRUCT_IF_C STT5177 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5177)");
    check_field_offset(lv, fa, 0, "STT5177.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5177");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5177");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5177, STT5177)
//============================================================================


struct  STT5187  {
  void *fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT5187) C1{ Fp FL:3 FL}



static void Test_STT5187()
{
  {
    init_simple_test("STT5187");
    static STRUCT_IF_C STT5187 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5187)");
    check_field_offset(lv, fa, 0, "STT5187.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5187");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5187");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5187, STT5187)
//============================================================================


struct  STT5197  {
  void *fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT5197) C1{ Fp Fs:8 FL}



static void Test_STT5197()
{
  {
    init_simple_test("STT5197");
    static STRUCT_IF_C STT5197 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5197)");
    check_field_offset(lv, fa, 0, "STT5197.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5197");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5197");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5197, STT5197)
//============================================================================


struct  STT5207  {
  void *fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT5207) C1{ Fp Fi:8 FL}



static void Test_STT5207()
{
  {
    init_simple_test("STT5207");
    static STRUCT_IF_C STT5207 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5207)");
    check_field_offset(lv, fa, 0, "STT5207.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5207");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5207");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5207, STT5207)
//============================================================================


struct  STT5217  {
  void *fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT5217) C1{ Fp FL:8 FL}



static void Test_STT5217()
{
  {
    init_simple_test("STT5217");
    static STRUCT_IF_C STT5217 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5217)");
    check_field_offset(lv, fa, 0, "STT5217.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5217");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5217");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5217, STT5217)
//============================================================================


struct  STT5227  {
  void *fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT5227) C1{ Fp Fi:18 FL}



static void Test_STT5227()
{
  {
    init_simple_test("STT5227");
    static STRUCT_IF_C STT5227 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5227)");
    check_field_offset(lv, fa, 0, "STT5227.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5227");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5227");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5227, STT5227)
//============================================================================


struct  STT5237  {
  void *fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT5237) C1{ Fp FL:18 FL}



static void Test_STT5237()
{
  {
    init_simple_test("STT5237");
    static STRUCT_IF_C STT5237 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT5237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5237)");
    check_field_offset(lv, fa, 0, "STT5237.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5237");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5237");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5237, STT5237)
//============================================================================


struct  STT5247  {
  void *fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT5247) C1{ Fp FL:48 FL}



static void Test_STT5247()
{
  {
    init_simple_test("STT5247");
    static STRUCT_IF_C STT5247 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT5247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5247)");
    check_field_offset(lv, fa, 0, "STT5247.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5247");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5247");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5247, STT5247)
//============================================================================


struct  STT518  {
  void *fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT518) C1{ Fp Fc:0 FD}



static void Test_STT518()
{
  {
    init_simple_test("STT518");
    static STRUCT_IF_C STT518 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT518)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT518)");
    check_field_offset(lv, fa, 0, "STT518.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT518.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT518, STT518)
//============================================================================


struct  STT528  {
  void *fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT528) C1{ Fp Fs:0 FD}



static void Test_STT528()
{
  {
    init_simple_test("STT528");
    static STRUCT_IF_C STT528 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT528)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT528)");
    check_field_offset(lv, fa, 0, "STT528.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT528.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT528, STT528)
//============================================================================


struct  STT538  {
  void *fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT538) C1{ Fp Fi:0 FD}



static void Test_STT538()
{
  {
    init_simple_test("STT538");
    static STRUCT_IF_C STT538 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT538)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT538)");
    check_field_offset(lv, fa, 0, "STT538.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT538.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT538, STT538)
//============================================================================


struct  STT548  {
  void *fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT548) C1{ Fp FL:0 FD}



static void Test_STT548()
{
  {
    init_simple_test("STT548");
    static STRUCT_IF_C STT548 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT548)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT548)");
    check_field_offset(lv, fa, 0, "STT548.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT548.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT548, STT548)
//============================================================================


struct  STT558  {
  void *fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT558) C1{ Fp Fc:3 FD}



static void Test_STT558()
{
  {
    init_simple_test("STT558");
    static STRUCT_IF_C STT558 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT558)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT558)");
    check_field_offset(lv, fa, 0, "STT558.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT558.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT558, STT558)
//============================================================================


struct  STT568  {
  void *fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT568) C1{ Fp Fs:3 FD}



static void Test_STT568()
{
  {
    init_simple_test("STT568");
    static STRUCT_IF_C STT568 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT568)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT568)");
    check_field_offset(lv, fa, 0, "STT568.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT568.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT568, STT568)
//============================================================================


struct  STT578  {
  void *fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT578) C1{ Fp Fi:3 FD}



static void Test_STT578()
{
  {
    init_simple_test("STT578");
    static STRUCT_IF_C STT578 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT578)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT578)");
    check_field_offset(lv, fa, 0, "STT578.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT578.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT578, STT578)
//============================================================================


struct  STT588  {
  void *fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT588) C1{ Fp FL:3 FD}



static void Test_STT588()
{
  {
    init_simple_test("STT588");
    static STRUCT_IF_C STT588 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT588)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT588)");
    check_field_offset(lv, fa, 0, "STT588.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT588.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT588, STT588)
//============================================================================


struct  STT598  {
  void *fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT598) C1{ Fp Fs:8 FD}



static void Test_STT598()
{
  {
    init_simple_test("STT598");
    static STRUCT_IF_C STT598 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT598)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT598)");
    check_field_offset(lv, fa, 0, "STT598.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT598.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT598, STT598)
//============================================================================


struct  STT5108  {
  void *fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT5108) C1{ Fp Fi:8 FD}



static void Test_STT5108()
{
  {
    init_simple_test("STT5108");
    static STRUCT_IF_C STT5108 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5108)");
    check_field_offset(lv, fa, 0, "STT5108.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5108, STT5108)
//============================================================================


struct  STT5118  {
  void *fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT5118) C1{ Fp FL:8 FD}



static void Test_STT5118()
{
  {
    init_simple_test("STT5118");
    static STRUCT_IF_C STT5118 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5118)");
    check_field_offset(lv, fa, 0, "STT5118.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5118, STT5118)
//============================================================================


struct  STT5128  {
  void *fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT5128) C1{ Fp Fi:18 FD}



static void Test_STT5128()
{
  {
    init_simple_test("STT5128");
    static STRUCT_IF_C STT5128 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5128)");
    check_field_offset(lv, fa, 0, "STT5128.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5128, STT5128)
//============================================================================


struct  STT5138  {
  void *fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT5138) C1{ Fp FL:18 FD}



static void Test_STT5138()
{
  {
    init_simple_test("STT5138");
    static STRUCT_IF_C STT5138 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5138)");
    check_field_offset(lv, fa, 0, "STT5138.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5138, STT5138)
//============================================================================


struct  STT5148  {
  void *fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT5148) C1{ Fp FL:48 FD}



static void Test_STT5148()
{
  {
    init_simple_test("STT5148");
    static STRUCT_IF_C STT5148 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT5148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5148)");
    check_field_offset(lv, fa, 0, "STT5148.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5148, STT5148)
//============================================================================


struct  STT5158  {
  void *fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT5158) C1{ Fp Fc:3 FD}



static void Test_STT5158()
{
  {
    init_simple_test("STT5158");
    static STRUCT_IF_C STT5158 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5158)");
    check_field_offset(lv, fa, 0, "STT5158.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5158");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5158");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5158, STT5158)
//============================================================================


struct  STT5168  {
  void *fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT5168) C1{ Fp Fs:3 FD}



static void Test_STT5168()
{
  {
    init_simple_test("STT5168");
    static STRUCT_IF_C STT5168 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5168)");
    check_field_offset(lv, fa, 0, "STT5168.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5168");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5168");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5168, STT5168)
//============================================================================


struct  STT5178  {
  void *fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT5178) C1{ Fp Fi:3 FD}



static void Test_STT5178()
{
  {
    init_simple_test("STT5178");
    static STRUCT_IF_C STT5178 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5178)");
    check_field_offset(lv, fa, 0, "STT5178.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5178");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5178");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5178, STT5178)
//============================================================================


struct  STT5188  {
  void *fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT5188) C1{ Fp FL:3 FD}



static void Test_STT5188()
{
  {
    init_simple_test("STT5188");
    static STRUCT_IF_C STT5188 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5188)");
    check_field_offset(lv, fa, 0, "STT5188.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5188");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5188");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5188, STT5188)
//============================================================================


struct  STT5198  {
  void *fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT5198) C1{ Fp Fs:8 FD}



static void Test_STT5198()
{
  {
    init_simple_test("STT5198");
    static STRUCT_IF_C STT5198 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5198)");
    check_field_offset(lv, fa, 0, "STT5198.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5198");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5198");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5198, STT5198)
//============================================================================


struct  STT5208  {
  void *fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT5208) C1{ Fp Fi:8 FD}



static void Test_STT5208()
{
  {
    init_simple_test("STT5208");
    static STRUCT_IF_C STT5208 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5208)");
    check_field_offset(lv, fa, 0, "STT5208.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5208");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5208");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5208, STT5208)
//============================================================================


struct  STT5218  {
  void *fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT5218) C1{ Fp FL:8 FD}



static void Test_STT5218()
{
  {
    init_simple_test("STT5218");
    static STRUCT_IF_C STT5218 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5218)");
    check_field_offset(lv, fa, 0, "STT5218.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5218");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5218");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5218, STT5218)
//============================================================================


struct  STT5228  {
  void *fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT5228) C1{ Fp Fi:18 FD}



static void Test_STT5228()
{
  {
    init_simple_test("STT5228");
    static STRUCT_IF_C STT5228 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5228)");
    check_field_offset(lv, fa, 0, "STT5228.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5228");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5228");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5228, STT5228)
//============================================================================


struct  STT5238  {
  void *fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT5238) C1{ Fp FL:18 FD}



static void Test_STT5238()
{
  {
    init_simple_test("STT5238");
    static STRUCT_IF_C STT5238 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT5238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5238)");
    check_field_offset(lv, fa, 0, "STT5238.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5238");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5238");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT5238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5238, STT5238)
//============================================================================


struct  STT5248  {
  void *fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT5248) C1{ Fp FL:48 FD}



static void Test_STT5248()
{
  {
    init_simple_test("STT5248");
    static STRUCT_IF_C STT5248 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT5248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT5248)");
    check_field_offset(lv, fa, 0, "STT5248.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5248");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5248");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT5248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5248, STT5248)
//============================================================================


struct  STT519  {
  void *fa;
  unsigned char  :0;
};
//SIG(1 STT519) C1{ Fp Fc:0}



static void Test_STT519()
{
  {
    init_simple_test("STT519");
    static STRUCT_IF_C STT519 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT519)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT519)");
    check_field_offset(lv, fa, 0, "STT519.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT519, STT519)
//============================================================================


struct  STT529  {
  void *fa;
  unsigned short  :0;
};
//SIG(1 STT529) C1{ Fp Fs:0}



static void Test_STT529()
{
  {
    init_simple_test("STT529");
    static STRUCT_IF_C STT529 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT529)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT529)");
    check_field_offset(lv, fa, 0, "STT529.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT529, STT529)
//============================================================================


struct  STT539  {
  void *fa;
  unsigned int  :0;
};
//SIG(1 STT539) C1{ Fp Fi:0}



static void Test_STT539()
{
  {
    init_simple_test("STT539");
    static STRUCT_IF_C STT539 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT539)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT539)");
    check_field_offset(lv, fa, 0, "STT539.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT539, STT539)
//============================================================================


struct  STT549  {
  void *fa;
  __tsu64  :0;
};
//SIG(1 STT549) C1{ Fp FL:0}



static void Test_STT549()
{
  {
    init_simple_test("STT549");
    static STRUCT_IF_C STT549 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT549)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT549)");
    check_field_offset(lv, fa, 0, "STT549.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT549, STT549)
//============================================================================


struct  STT559  {
  void *fa;
  unsigned char  :3;
};
//SIG(1 STT559) C1{ Fp Fc:3}



static void Test_STT559()
{
  {
    init_simple_test("STT559");
    static STRUCT_IF_C STT559 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT559)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT559)");
    check_field_offset(lv, fa, 0, "STT559.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT559, STT559)
//============================================================================


struct  STT569  {
  void *fa;
  unsigned short  :3;
};
//SIG(1 STT569) C1{ Fp Fs:3}



static void Test_STT569()
{
  {
    init_simple_test("STT569");
    static STRUCT_IF_C STT569 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT569)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT569)");
    check_field_offset(lv, fa, 0, "STT569.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT569, STT569)
//============================================================================


struct  STT579  {
  void *fa;
  unsigned int  :3;
};
//SIG(1 STT579) C1{ Fp Fi:3}



static void Test_STT579()
{
  {
    init_simple_test("STT579");
    static STRUCT_IF_C STT579 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT579)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT579)");
    check_field_offset(lv, fa, 0, "STT579.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT579, STT579)
//============================================================================


struct  STT589  {
  void *fa;
  __tsu64  :3;
};
//SIG(1 STT589) C1{ Fp FL:3}



static void Test_STT589()
{
  {
    init_simple_test("STT589");
    static STRUCT_IF_C STT589 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT589)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT589)");
    check_field_offset(lv, fa, 0, "STT589.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT589, STT589)
//============================================================================


struct  STT599  {
  void *fa;
  unsigned short  :8;
};
//SIG(1 STT599) C1{ Fp Fs:8}



static void Test_STT599()
{
  {
    init_simple_test("STT599");
    static STRUCT_IF_C STT599 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT599)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT599)");
    check_field_offset(lv, fa, 0, "STT599.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT599, STT599)
//============================================================================


struct  STT5109  {
  void *fa;
  unsigned int  :8;
};
//SIG(1 STT5109) C1{ Fp Fi:8}



static void Test_STT5109()
{
  {
    init_simple_test("STT5109");
    static STRUCT_IF_C STT5109 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5109)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5109)");
    check_field_offset(lv, fa, 0, "STT5109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5109, STT5109)
//============================================================================


struct  STT5119  {
  void *fa;
  __tsu64  :8;
};
//SIG(1 STT5119) C1{ Fp FL:8}



static void Test_STT5119()
{
  {
    init_simple_test("STT5119");
    static STRUCT_IF_C STT5119 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5119)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5119)");
    check_field_offset(lv, fa, 0, "STT5119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5119, STT5119)
//============================================================================


struct  STT5129  {
  void *fa;
  unsigned int  :18;
};
//SIG(1 STT5129) C1{ Fp Fi:18}



static void Test_STT5129()
{
  {
    init_simple_test("STT5129");
    static STRUCT_IF_C STT5129 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5129)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5129)");
    check_field_offset(lv, fa, 0, "STT5129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5129, STT5129)
//============================================================================


struct  STT5139  {
  void *fa;
  __tsu64  :18;
};
//SIG(1 STT5139) C1{ Fp FL:18}



static void Test_STT5139()
{
  {
    init_simple_test("STT5139");
    static STRUCT_IF_C STT5139 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5139)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5139)");
    check_field_offset(lv, fa, 0, "STT5139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5139, STT5139)
//============================================================================


struct  STT5149  {
  void *fa;
  __tsu64  :48;
};
//SIG(1 STT5149) C1{ Fp FL:48}



static void Test_STT5149()
{
  {
    init_simple_test("STT5149");
    static STRUCT_IF_C STT5149 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5149)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5149)");
    check_field_offset(lv, fa, 0, "STT5149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5149, STT5149)
//============================================================================


struct  STT5159  {
  void *fa;
  unsigned char bf:3;
};
//SIG(1 STT5159) C1{ Fp Fc:3}



static void Test_STT5159()
{
  {
    init_simple_test("STT5159");
    static STRUCT_IF_C STT5159 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5159)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5159)");
    check_field_offset(lv, fa, 0, "STT5159.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5159");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5159, STT5159)
//============================================================================


struct  STT5169  {
  void *fa;
  unsigned short bf:3;
};
//SIG(1 STT5169) C1{ Fp Fs:3}



static void Test_STT5169()
{
  {
    init_simple_test("STT5169");
    static STRUCT_IF_C STT5169 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5169)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5169)");
    check_field_offset(lv, fa, 0, "STT5169.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5169");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5169, STT5169)
//============================================================================


struct  STT5179  {
  void *fa;
  unsigned int bf:3;
};
//SIG(1 STT5179) C1{ Fp Fi:3}



static void Test_STT5179()
{
  {
    init_simple_test("STT5179");
    static STRUCT_IF_C STT5179 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5179)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5179)");
    check_field_offset(lv, fa, 0, "STT5179.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5179");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5179, STT5179)
//============================================================================


struct  STT5189  {
  void *fa;
  __tsu64 bf:3;
};
//SIG(1 STT5189) C1{ Fp FL:3}



static void Test_STT5189()
{
  {
    init_simple_test("STT5189");
    static STRUCT_IF_C STT5189 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5189)");
    check_field_offset(lv, fa, 0, "STT5189.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, 1, "STT5189");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 3, hide_ull(1LL<<2), "STT5189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5189, STT5189)
//============================================================================


struct  STT5199  {
  void *fa;
  unsigned short bf:8;
};
//SIG(1 STT5199) C1{ Fp Fs:8}



static void Test_STT5199()
{
  {
    init_simple_test("STT5199");
    static STRUCT_IF_C STT5199 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5199)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5199)");
    check_field_offset(lv, fa, 0, "STT5199.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5199");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5199, STT5199)
//============================================================================


struct  STT5209  {
  void *fa;
  unsigned int bf:8;
};
//SIG(1 STT5209) C1{ Fp Fi:8}



static void Test_STT5209()
{
  {
    init_simple_test("STT5209");
    static STRUCT_IF_C STT5209 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5209)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5209)");
    check_field_offset(lv, fa, 0, "STT5209.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5209");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5209, STT5209)
//============================================================================


struct  STT5219  {
  void *fa;
  __tsu64 bf:8;
};
//SIG(1 STT5219) C1{ Fp FL:8}



static void Test_STT5219()
{
  {
    init_simple_test("STT5219");
    static STRUCT_IF_C STT5219 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5219)");
    check_field_offset(lv, fa, 0, "STT5219.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, 1, "STT5219");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 8, hide_ull(1LL<<7), "STT5219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5219, STT5219)
//============================================================================


struct  STT5229  {
  void *fa;
  unsigned int bf:18;
};
//SIG(1 STT5229) C1{ Fp Fi:18}



static void Test_STT5229()
{
  {
    init_simple_test("STT5229");
    static STRUCT_IF_C STT5229 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5229)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5229)");
    check_field_offset(lv, fa, 0, "STT5229.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5229");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5229, STT5229)
//============================================================================


struct  STT5239  {
  void *fa;
  __tsu64 bf:18;
};
//SIG(1 STT5239) C1{ Fp FL:18}



static void Test_STT5239()
{
  {
    init_simple_test("STT5239");
    static STRUCT_IF_C STT5239 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT5239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5239)");
    check_field_offset(lv, fa, 0, "STT5239.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, 1, "STT5239");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 18, hide_ull(1LL<<17), "STT5239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5239, STT5239)
//============================================================================


struct  STT5249  {
  void *fa;
  __tsu64 bf:48;
};
//SIG(1 STT5249) C1{ Fp FL:48}



static void Test_STT5249()
{
  {
    init_simple_test("STT5249");
    static STRUCT_IF_C STT5249 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT5249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT5249)");
    check_field_offset(lv, fa, 0, "STT5249.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT5249");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT5249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT5249, STT5249)
//============================================================================


struct  STT610  {
  float fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT610) C1{ Fi Fc:0 Fc}



static void Test_STT610()
{
  {
    init_simple_test("STT610");
    static STRUCT_IF_C STT610 lv;
    check2(sizeof(lv), 8, "sizeof(STT610)");
    check2(__alignof__(lv), 4, "__alignof__(STT610)");
    check_field_offset(lv, fa, 0, "STT610.fa");
    check_field_offset(lv, fb, 4, "STT610.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT610, STT610)
//============================================================================


struct  STT620  {
  float fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT620) C1{ Fi Fs:0 Fc}



static void Test_STT620()
{
  {
    init_simple_test("STT620");
    static STRUCT_IF_C STT620 lv;
    check2(sizeof(lv), 8, "sizeof(STT620)");
    check2(__alignof__(lv), 4, "__alignof__(STT620)");
    check_field_offset(lv, fa, 0, "STT620.fa");
    check_field_offset(lv, fb, 4, "STT620.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT620, STT620)
//============================================================================


struct  STT630  {
  float fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT630) C1{ Fi Fi:0 Fc}



static void Test_STT630()
{
  {
    init_simple_test("STT630");
    static STRUCT_IF_C STT630 lv;
    check2(sizeof(lv), 8, "sizeof(STT630)");
    check2(__alignof__(lv), 4, "__alignof__(STT630)");
    check_field_offset(lv, fa, 0, "STT630.fa");
    check_field_offset(lv, fb, 4, "STT630.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT630, STT630)
//============================================================================


struct  STT640  {
  float fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT640) C1{ Fi FL:0 Fc}



static void Test_STT640()
{
  {
    init_simple_test("STT640");
    static STRUCT_IF_C STT640 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT640)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT640)");
    check_field_offset(lv, fa, 0, "STT640.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT640.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT640, STT640)
//============================================================================


struct  STT650  {
  float fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT650) C1{ Fi Fc:3 Fc}



static void Test_STT650()
{
  {
    init_simple_test("STT650");
    static STRUCT_IF_C STT650 lv;
    check2(sizeof(lv), 8, "sizeof(STT650)");
    check2(__alignof__(lv), 4, "__alignof__(STT650)");
    check_field_offset(lv, fa, 0, "STT650.fa");
    check_field_offset(lv, fb, 5, "STT650.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT650, STT650)
//============================================================================


struct  STT660  {
  float fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT660) C1{ Fi Fs:3 Fc}



static void Test_STT660()
{
  {
    init_simple_test("STT660");
    static STRUCT_IF_C STT660 lv;
    check2(sizeof(lv), 8, "sizeof(STT660)");
    check2(__alignof__(lv), 4, "__alignof__(STT660)");
    check_field_offset(lv, fa, 0, "STT660.fa");
    check_field_offset(lv, fb, 5, "STT660.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT660, STT660)
//============================================================================


struct  STT670  {
  float fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT670) C1{ Fi Fi:3 Fc}



static void Test_STT670()
{
  {
    init_simple_test("STT670");
    static STRUCT_IF_C STT670 lv;
    check2(sizeof(lv), 8, "sizeof(STT670)");
    check2(__alignof__(lv), 4, "__alignof__(STT670)");
    check_field_offset(lv, fa, 0, "STT670.fa");
    check_field_offset(lv, fb, 5, "STT670.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT670, STT670)
//============================================================================


struct  STT680  {
  float fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT680) C1{ Fi FL:3 Fc}



static void Test_STT680()
{
  {
    init_simple_test("STT680");
    static STRUCT_IF_C STT680 lv;
    check2(sizeof(lv), 8, "sizeof(STT680)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT680)");
    check_field_offset(lv, fa, 0, "STT680.fa");
    check_field_offset(lv, fb, 5, "STT680.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT680, STT680)
//============================================================================


struct  STT690  {
  float fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT690) C1{ Fi Fs:8 Fc}



static void Test_STT690()
{
  {
    init_simple_test("STT690");
    static STRUCT_IF_C STT690 lv;
    check2(sizeof(lv), 8, "sizeof(STT690)");
    check2(__alignof__(lv), 4, "__alignof__(STT690)");
    check_field_offset(lv, fa, 0, "STT690.fa");
    check_field_offset(lv, fb, 5, "STT690.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT690, STT690)
//============================================================================


struct  STT6100  {
  float fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT6100) C1{ Fi Fi:8 Fc}



static void Test_STT6100()
{
  {
    init_simple_test("STT6100");
    static STRUCT_IF_C STT6100 lv;
    check2(sizeof(lv), 8, "sizeof(STT6100)");
    check2(__alignof__(lv), 4, "__alignof__(STT6100)");
    check_field_offset(lv, fa, 0, "STT6100.fa");
    check_field_offset(lv, fb, 5, "STT6100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6100, STT6100)
//============================================================================


struct  STT6110  {
  float fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT6110) C1{ Fi FL:8 Fc}



static void Test_STT6110()
{
  {
    init_simple_test("STT6110");
    static STRUCT_IF_C STT6110 lv;
    check2(sizeof(lv), 8, "sizeof(STT6110)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6110)");
    check_field_offset(lv, fa, 0, "STT6110.fa");
    check_field_offset(lv, fb, 5, "STT6110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6110, STT6110)
//============================================================================


struct  STT6120  {
  float fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT6120) C1{ Fi Fi:18 Fc}



static void Test_STT6120()
{
  {
    init_simple_test("STT6120");
    static STRUCT_IF_C STT6120 lv;
    check2(sizeof(lv), 8, "sizeof(STT6120)");
    check2(__alignof__(lv), 4, "__alignof__(STT6120)");
    check_field_offset(lv, fa, 0, "STT6120.fa");
    check_field_offset(lv, fb, 7, "STT6120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6120, STT6120)
//============================================================================


struct  STT6130  {
  float fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT6130) C1{ Fi FL:18 Fc}



static void Test_STT6130()
{
  {
    init_simple_test("STT6130");
    static STRUCT_IF_C STT6130 lv;
    check2(sizeof(lv), 8, "sizeof(STT6130)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6130)");
    check_field_offset(lv, fa, 0, "STT6130.fa");
    check_field_offset(lv, fb, 7, "STT6130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6130, STT6130)
//============================================================================


struct  STT6140  {
  float fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT6140) C1{ Fi FL:48 Fc}



static void Test_STT6140()
{
  {
    init_simple_test("STT6140");
    static STRUCT_IF_C STT6140 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6140)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6140)");
    check_field_offset(lv, fa, 0, "STT6140.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT6140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6140, STT6140)
//============================================================================


struct  STT6150  {
  float fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT6150) C1{ Fi Fc:3 Fc}



static void Test_STT6150()
{
  {
    init_simple_test("STT6150");
    static STRUCT_IF_C STT6150 lv;
    check2(sizeof(lv), 8, "sizeof(STT6150)");
    check2(__alignof__(lv), 4, "__alignof__(STT6150)");
    check_field_offset(lv, fa, 0, "STT6150.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6150");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6150");
    check_field_offset(lv, fb, 5, "STT6150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6150, STT6150)
//============================================================================


struct  STT6160  {
  float fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT6160) C1{ Fi Fs:3 Fc}



static void Test_STT6160()
{
  {
    init_simple_test("STT6160");
    static STRUCT_IF_C STT6160 lv;
    check2(sizeof(lv), 8, "sizeof(STT6160)");
    check2(__alignof__(lv), 4, "__alignof__(STT6160)");
    check_field_offset(lv, fa, 0, "STT6160.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6160");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6160");
    check_field_offset(lv, fb, 5, "STT6160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6160, STT6160)
//============================================================================


struct  STT6170  {
  float fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT6170) C1{ Fi Fi:3 Fc}



static void Test_STT6170()
{
  {
    init_simple_test("STT6170");
    static STRUCT_IF_C STT6170 lv;
    check2(sizeof(lv), 8, "sizeof(STT6170)");
    check2(__alignof__(lv), 4, "__alignof__(STT6170)");
    check_field_offset(lv, fa, 0, "STT6170.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6170");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6170");
    check_field_offset(lv, fb, 5, "STT6170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6170, STT6170)
//============================================================================


struct  STT6180  {
  float fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT6180) C1{ Fi FL:3 Fc}



static void Test_STT6180()
{
  {
    init_simple_test("STT6180");
    static STRUCT_IF_C STT6180 lv;
    check2(sizeof(lv), 8, "sizeof(STT6180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6180)");
    check_field_offset(lv, fa, 0, "STT6180.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6180");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6180");
    check_field_offset(lv, fb, 5, "STT6180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6180, STT6180)
//============================================================================


struct  STT6190  {
  float fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT6190) C1{ Fi Fs:8 Fc}



static void Test_STT6190()
{
  {
    init_simple_test("STT6190");
    static STRUCT_IF_C STT6190 lv;
    check2(sizeof(lv), 8, "sizeof(STT6190)");
    check2(__alignof__(lv), 4, "__alignof__(STT6190)");
    check_field_offset(lv, fa, 0, "STT6190.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6190");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6190");
    check_field_offset(lv, fb, 5, "STT6190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6190, STT6190)
//============================================================================


struct  STT6200  {
  float fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT6200) C1{ Fi Fi:8 Fc}



static void Test_STT6200()
{
  {
    init_simple_test("STT6200");
    static STRUCT_IF_C STT6200 lv;
    check2(sizeof(lv), 8, "sizeof(STT6200)");
    check2(__alignof__(lv), 4, "__alignof__(STT6200)");
    check_field_offset(lv, fa, 0, "STT6200.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6200");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6200");
    check_field_offset(lv, fb, 5, "STT6200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6200, STT6200)
//============================================================================


struct  STT6210  {
  float fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT6210) C1{ Fi FL:8 Fc}



static void Test_STT6210()
{
  {
    init_simple_test("STT6210");
    static STRUCT_IF_C STT6210 lv;
    check2(sizeof(lv), 8, "sizeof(STT6210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6210)");
    check_field_offset(lv, fa, 0, "STT6210.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6210");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6210");
    check_field_offset(lv, fb, 5, "STT6210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6210, STT6210)
//============================================================================


struct  STT6220  {
  float fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT6220) C1{ Fi Fi:18 Fc}



static void Test_STT6220()
{
  {
    init_simple_test("STT6220");
    static STRUCT_IF_C STT6220 lv;
    check2(sizeof(lv), 8, "sizeof(STT6220)");
    check2(__alignof__(lv), 4, "__alignof__(STT6220)");
    check_field_offset(lv, fa, 0, "STT6220.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6220");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6220");
    check_field_offset(lv, fb, 7, "STT6220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6220, STT6220)
//============================================================================


struct  STT6230  {
  float fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT6230) C1{ Fi FL:18 Fc}



static void Test_STT6230()
{
  {
    init_simple_test("STT6230");
    static STRUCT_IF_C STT6230 lv;
    check2(sizeof(lv), 8, "sizeof(STT6230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6230)");
    check_field_offset(lv, fa, 0, "STT6230.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6230");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6230");
    check_field_offset(lv, fb, 7, "STT6230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6230, STT6230)
//============================================================================


struct  STT6240  {
  float fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT6240) C1{ Fi FL:48 Fc}



static void Test_STT6240()
{
  {
    init_simple_test("STT6240");
    static STRUCT_IF_C STT6240 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6240)");
    check_field_offset(lv, fa, 0, "STT6240.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6240");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6240");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT6240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6240, STT6240)
//============================================================================


struct  STT611  {
  float fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT611) C1{ Fi Fc:0 Fs}



static void Test_STT611()
{
  {
    init_simple_test("STT611");
    static STRUCT_IF_C STT611 lv;
    check2(sizeof(lv), 8, "sizeof(STT611)");
    check2(__alignof__(lv), 4, "__alignof__(STT611)");
    check_field_offset(lv, fa, 0, "STT611.fa");
    check_field_offset(lv, fb, 4, "STT611.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT611, STT611)
//============================================================================


struct  STT621  {
  float fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT621) C1{ Fi Fs:0 Fs}



static void Test_STT621()
{
  {
    init_simple_test("STT621");
    static STRUCT_IF_C STT621 lv;
    check2(sizeof(lv), 8, "sizeof(STT621)");
    check2(__alignof__(lv), 4, "__alignof__(STT621)");
    check_field_offset(lv, fa, 0, "STT621.fa");
    check_field_offset(lv, fb, 4, "STT621.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT621, STT621)
//============================================================================


struct  STT631  {
  float fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT631) C1{ Fi Fi:0 Fs}



static void Test_STT631()
{
  {
    init_simple_test("STT631");
    static STRUCT_IF_C STT631 lv;
    check2(sizeof(lv), 8, "sizeof(STT631)");
    check2(__alignof__(lv), 4, "__alignof__(STT631)");
    check_field_offset(lv, fa, 0, "STT631.fa");
    check_field_offset(lv, fb, 4, "STT631.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT631, STT631)
//============================================================================


struct  STT641  {
  float fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT641) C1{ Fi FL:0 Fs}



static void Test_STT641()
{
  {
    init_simple_test("STT641");
    static STRUCT_IF_C STT641 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT641)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT641)");
    check_field_offset(lv, fa, 0, "STT641.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT641.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT641, STT641)
//============================================================================


struct  STT651  {
  float fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT651) C1{ Fi Fc:3 Fs}



static void Test_STT651()
{
  {
    init_simple_test("STT651");
    static STRUCT_IF_C STT651 lv;
    check2(sizeof(lv), 8, "sizeof(STT651)");
    check2(__alignof__(lv), 4, "__alignof__(STT651)");
    check_field_offset(lv, fa, 0, "STT651.fa");
    check_field_offset(lv, fb, 6, "STT651.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT651, STT651)
//============================================================================


struct  STT661  {
  float fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT661) C1{ Fi Fs:3 Fs}



static void Test_STT661()
{
  {
    init_simple_test("STT661");
    static STRUCT_IF_C STT661 lv;
    check2(sizeof(lv), 8, "sizeof(STT661)");
    check2(__alignof__(lv), 4, "__alignof__(STT661)");
    check_field_offset(lv, fa, 0, "STT661.fa");
    check_field_offset(lv, fb, 6, "STT661.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT661, STT661)
//============================================================================


struct  STT671  {
  float fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT671) C1{ Fi Fi:3 Fs}



static void Test_STT671()
{
  {
    init_simple_test("STT671");
    static STRUCT_IF_C STT671 lv;
    check2(sizeof(lv), 8, "sizeof(STT671)");
    check2(__alignof__(lv), 4, "__alignof__(STT671)");
    check_field_offset(lv, fa, 0, "STT671.fa");
    check_field_offset(lv, fb, 6, "STT671.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT671, STT671)
//============================================================================


struct  STT681  {
  float fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT681) C1{ Fi FL:3 Fs}



static void Test_STT681()
{
  {
    init_simple_test("STT681");
    static STRUCT_IF_C STT681 lv;
    check2(sizeof(lv), 8, "sizeof(STT681)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT681)");
    check_field_offset(lv, fa, 0, "STT681.fa");
    check_field_offset(lv, fb, 6, "STT681.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT681, STT681)
//============================================================================


struct  STT691  {
  float fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT691) C1{ Fi Fs:8 Fs}



static void Test_STT691()
{
  {
    init_simple_test("STT691");
    static STRUCT_IF_C STT691 lv;
    check2(sizeof(lv), 8, "sizeof(STT691)");
    check2(__alignof__(lv), 4, "__alignof__(STT691)");
    check_field_offset(lv, fa, 0, "STT691.fa");
    check_field_offset(lv, fb, 6, "STT691.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT691, STT691)
//============================================================================


struct  STT6101  {
  float fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT6101) C1{ Fi Fi:8 Fs}



static void Test_STT6101()
{
  {
    init_simple_test("STT6101");
    static STRUCT_IF_C STT6101 lv;
    check2(sizeof(lv), 8, "sizeof(STT6101)");
    check2(__alignof__(lv), 4, "__alignof__(STT6101)");
    check_field_offset(lv, fa, 0, "STT6101.fa");
    check_field_offset(lv, fb, 6, "STT6101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6101, STT6101)
//============================================================================


struct  STT6111  {
  float fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT6111) C1{ Fi FL:8 Fs}



static void Test_STT6111()
{
  {
    init_simple_test("STT6111");
    static STRUCT_IF_C STT6111 lv;
    check2(sizeof(lv), 8, "sizeof(STT6111)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6111)");
    check_field_offset(lv, fa, 0, "STT6111.fa");
    check_field_offset(lv, fb, 6, "STT6111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6111, STT6111)
//============================================================================


struct  STT6121  {
  float fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT6121) C1{ Fi Fi:18 Fs}



static void Test_STT6121()
{
  {
    init_simple_test("STT6121");
    static STRUCT_IF_C STT6121 lv;
    check2(sizeof(lv), 12, "sizeof(STT6121)");
    check2(__alignof__(lv), 4, "__alignof__(STT6121)");
    check_field_offset(lv, fa, 0, "STT6121.fa");
    check_field_offset(lv, fb, 8, "STT6121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6121, STT6121)
//============================================================================


struct  STT6131  {
  float fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT6131) C1{ Fi FL:18 Fs}



static void Test_STT6131()
{
  {
    init_simple_test("STT6131");
    static STRUCT_IF_C STT6131 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT6131)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6131)");
    check_field_offset(lv, fa, 0, "STT6131.fa");
    check_field_offset(lv, fb, 8, "STT6131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6131, STT6131)
//============================================================================


struct  STT6141  {
  float fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT6141) C1{ Fi FL:48 Fs}



static void Test_STT6141()
{
  {
    init_simple_test("STT6141");
    static STRUCT_IF_C STT6141 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6141)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6141)");
    check_field_offset(lv, fa, 0, "STT6141.fa");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT6141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6141, STT6141)
//============================================================================


struct  STT6151  {
  float fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT6151) C1{ Fi Fc:3 Fs}



static void Test_STT6151()
{
  {
    init_simple_test("STT6151");
    static STRUCT_IF_C STT6151 lv;
    check2(sizeof(lv), 8, "sizeof(STT6151)");
    check2(__alignof__(lv), 4, "__alignof__(STT6151)");
    check_field_offset(lv, fa, 0, "STT6151.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6151");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6151");
    check_field_offset(lv, fb, 6, "STT6151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6151, STT6151)
//============================================================================


struct  STT6161  {
  float fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT6161) C1{ Fi Fs:3 Fs}



static void Test_STT6161()
{
  {
    init_simple_test("STT6161");
    static STRUCT_IF_C STT6161 lv;
    check2(sizeof(lv), 8, "sizeof(STT6161)");
    check2(__alignof__(lv), 4, "__alignof__(STT6161)");
    check_field_offset(lv, fa, 0, "STT6161.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6161");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6161");
    check_field_offset(lv, fb, 6, "STT6161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6161, STT6161)
//============================================================================


struct  STT6171  {
  float fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT6171) C1{ Fi Fi:3 Fs}



static void Test_STT6171()
{
  {
    init_simple_test("STT6171");
    static STRUCT_IF_C STT6171 lv;
    check2(sizeof(lv), 8, "sizeof(STT6171)");
    check2(__alignof__(lv), 4, "__alignof__(STT6171)");
    check_field_offset(lv, fa, 0, "STT6171.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6171");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6171");
    check_field_offset(lv, fb, 6, "STT6171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6171, STT6171)
//============================================================================


struct  STT6181  {
  float fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT6181) C1{ Fi FL:3 Fs}



static void Test_STT6181()
{
  {
    init_simple_test("STT6181");
    static STRUCT_IF_C STT6181 lv;
    check2(sizeof(lv), 8, "sizeof(STT6181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6181)");
    check_field_offset(lv, fa, 0, "STT6181.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6181");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6181");
    check_field_offset(lv, fb, 6, "STT6181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6181, STT6181)
//============================================================================


struct  STT6191  {
  float fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT6191) C1{ Fi Fs:8 Fs}



static void Test_STT6191()
{
  {
    init_simple_test("STT6191");
    static STRUCT_IF_C STT6191 lv;
    check2(sizeof(lv), 8, "sizeof(STT6191)");
    check2(__alignof__(lv), 4, "__alignof__(STT6191)");
    check_field_offset(lv, fa, 0, "STT6191.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6191");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6191");
    check_field_offset(lv, fb, 6, "STT6191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6191, STT6191)
//============================================================================


struct  STT6201  {
  float fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT6201) C1{ Fi Fi:8 Fs}



static void Test_STT6201()
{
  {
    init_simple_test("STT6201");
    static STRUCT_IF_C STT6201 lv;
    check2(sizeof(lv), 8, "sizeof(STT6201)");
    check2(__alignof__(lv), 4, "__alignof__(STT6201)");
    check_field_offset(lv, fa, 0, "STT6201.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6201");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6201");
    check_field_offset(lv, fb, 6, "STT6201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6201, STT6201)
//============================================================================


struct  STT6211  {
  float fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT6211) C1{ Fi FL:8 Fs}



static void Test_STT6211()
{
  {
    init_simple_test("STT6211");
    static STRUCT_IF_C STT6211 lv;
    check2(sizeof(lv), 8, "sizeof(STT6211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6211)");
    check_field_offset(lv, fa, 0, "STT6211.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6211");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6211");
    check_field_offset(lv, fb, 6, "STT6211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6211, STT6211)
//============================================================================


struct  STT6221  {
  float fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT6221) C1{ Fi Fi:18 Fs}



static void Test_STT6221()
{
  {
    init_simple_test("STT6221");
    static STRUCT_IF_C STT6221 lv;
    check2(sizeof(lv), 12, "sizeof(STT6221)");
    check2(__alignof__(lv), 4, "__alignof__(STT6221)");
    check_field_offset(lv, fa, 0, "STT6221.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6221");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6221");
    check_field_offset(lv, fb, 8, "STT6221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6221, STT6221)
//============================================================================


struct  STT6231  {
  float fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT6231) C1{ Fi FL:18 Fs}



static void Test_STT6231()
{
  {
    init_simple_test("STT6231");
    static STRUCT_IF_C STT6231 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6231)");
    check_field_offset(lv, fa, 0, "STT6231.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6231");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6231");
    check_field_offset(lv, fb, 8, "STT6231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6231, STT6231)
//============================================================================


struct  STT6241  {
  float fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT6241) C1{ Fi FL:48 Fs}



static void Test_STT6241()
{
  {
    init_simple_test("STT6241");
    static STRUCT_IF_C STT6241 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6241)");
    check_field_offset(lv, fa, 0, "STT6241.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6241");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6241");
    check_field_offset(lv, fb, ABISELECT(14,10), "STT6241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6241, STT6241)
//============================================================================


struct  STT612  {
  float fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT612) C1{ Fi Fc:0 Fi}



static void Test_STT612()
{
  {
    init_simple_test("STT612");
    static STRUCT_IF_C STT612 lv;
    check2(sizeof(lv), 8, "sizeof(STT612)");
    check2(__alignof__(lv), 4, "__alignof__(STT612)");
    check_field_offset(lv, fa, 0, "STT612.fa");
    check_field_offset(lv, fb, 4, "STT612.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT612, STT612)
//============================================================================


struct  STT622  {
  float fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT622) C1{ Fi Fs:0 Fi}



static void Test_STT622()
{
  {
    init_simple_test("STT622");
    static STRUCT_IF_C STT622 lv;
    check2(sizeof(lv), 8, "sizeof(STT622)");
    check2(__alignof__(lv), 4, "__alignof__(STT622)");
    check_field_offset(lv, fa, 0, "STT622.fa");
    check_field_offset(lv, fb, 4, "STT622.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT622, STT622)
//============================================================================


struct  STT632  {
  float fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT632) C1{ Fi Fi:0 Fi}



static void Test_STT632()
{
  {
    init_simple_test("STT632");
    static STRUCT_IF_C STT632 lv;
    check2(sizeof(lv), 8, "sizeof(STT632)");
    check2(__alignof__(lv), 4, "__alignof__(STT632)");
    check_field_offset(lv, fa, 0, "STT632.fa");
    check_field_offset(lv, fb, 4, "STT632.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT632, STT632)
//============================================================================


struct  STT642  {
  float fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT642) C1{ Fi FL:0 Fi}



static void Test_STT642()
{
  {
    init_simple_test("STT642");
    static STRUCT_IF_C STT642 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT642)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT642)");
    check_field_offset(lv, fa, 0, "STT642.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT642.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT642, STT642)
//============================================================================


struct  STT652  {
  float fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT652) C1{ Fi Fc:3 Fi}



static void Test_STT652()
{
  {
    init_simple_test("STT652");
    static STRUCT_IF_C STT652 lv;
    check2(sizeof(lv), 12, "sizeof(STT652)");
    check2(__alignof__(lv), 4, "__alignof__(STT652)");
    check_field_offset(lv, fa, 0, "STT652.fa");
    check_field_offset(lv, fb, 8, "STT652.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT652, STT652)
//============================================================================


struct  STT662  {
  float fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT662) C1{ Fi Fs:3 Fi}



static void Test_STT662()
{
  {
    init_simple_test("STT662");
    static STRUCT_IF_C STT662 lv;
    check2(sizeof(lv), 12, "sizeof(STT662)");
    check2(__alignof__(lv), 4, "__alignof__(STT662)");
    check_field_offset(lv, fa, 0, "STT662.fa");
    check_field_offset(lv, fb, 8, "STT662.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT662, STT662)
//============================================================================


struct  STT672  {
  float fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT672) C1{ Fi Fi:3 Fi}



static void Test_STT672()
{
  {
    init_simple_test("STT672");
    static STRUCT_IF_C STT672 lv;
    check2(sizeof(lv), 12, "sizeof(STT672)");
    check2(__alignof__(lv), 4, "__alignof__(STT672)");
    check_field_offset(lv, fa, 0, "STT672.fa");
    check_field_offset(lv, fb, 8, "STT672.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT672, STT672)
//============================================================================


struct  STT682  {
  float fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT682) C1{ Fi FL:3 Fi}



static void Test_STT682()
{
  {
    init_simple_test("STT682");
    static STRUCT_IF_C STT682 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT682)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT682)");
    check_field_offset(lv, fa, 0, "STT682.fa");
    check_field_offset(lv, fb, 8, "STT682.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT682, STT682)
//============================================================================


struct  STT692  {
  float fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT692) C1{ Fi Fs:8 Fi}



static void Test_STT692()
{
  {
    init_simple_test("STT692");
    static STRUCT_IF_C STT692 lv;
    check2(sizeof(lv), 12, "sizeof(STT692)");
    check2(__alignof__(lv), 4, "__alignof__(STT692)");
    check_field_offset(lv, fa, 0, "STT692.fa");
    check_field_offset(lv, fb, 8, "STT692.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT692, STT692)
//============================================================================


struct  STT6102  {
  float fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT6102) C1{ Fi Fi:8 Fi}



static void Test_STT6102()
{
  {
    init_simple_test("STT6102");
    static STRUCT_IF_C STT6102 lv;
    check2(sizeof(lv), 12, "sizeof(STT6102)");
    check2(__alignof__(lv), 4, "__alignof__(STT6102)");
    check_field_offset(lv, fa, 0, "STT6102.fa");
    check_field_offset(lv, fb, 8, "STT6102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6102, STT6102)
//============================================================================


struct  STT6112  {
  float fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT6112) C1{ Fi FL:8 Fi}



static void Test_STT6112()
{
  {
    init_simple_test("STT6112");
    static STRUCT_IF_C STT6112 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT6112)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6112)");
    check_field_offset(lv, fa, 0, "STT6112.fa");
    check_field_offset(lv, fb, 8, "STT6112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6112, STT6112)
//============================================================================


struct  STT6122  {
  float fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT6122) C1{ Fi Fi:18 Fi}



static void Test_STT6122()
{
  {
    init_simple_test("STT6122");
    static STRUCT_IF_C STT6122 lv;
    check2(sizeof(lv), 12, "sizeof(STT6122)");
    check2(__alignof__(lv), 4, "__alignof__(STT6122)");
    check_field_offset(lv, fa, 0, "STT6122.fa");
    check_field_offset(lv, fb, 8, "STT6122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6122, STT6122)
//============================================================================


struct  STT6132  {
  float fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT6132) C1{ Fi FL:18 Fi}



static void Test_STT6132()
{
  {
    init_simple_test("STT6132");
    static STRUCT_IF_C STT6132 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT6132)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6132)");
    check_field_offset(lv, fa, 0, "STT6132.fa");
    check_field_offset(lv, fb, 8, "STT6132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6132, STT6132)
//============================================================================


struct  STT6142  {
  float fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT6142) C1{ Fi FL:48 Fi}



static void Test_STT6142()
{
  {
    init_simple_test("STT6142");
    static STRUCT_IF_C STT6142 lv;
    check2(sizeof(lv), ABISELECT(20,16), "sizeof(STT6142)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6142)");
    check_field_offset(lv, fa, 0, "STT6142.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6142, STT6142)
//============================================================================


struct  STT6152  {
  float fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT6152) C1{ Fi Fc:3 Fi}



static void Test_STT6152()
{
  {
    init_simple_test("STT6152");
    static STRUCT_IF_C STT6152 lv;
    check2(sizeof(lv), 12, "sizeof(STT6152)");
    check2(__alignof__(lv), 4, "__alignof__(STT6152)");
    check_field_offset(lv, fa, 0, "STT6152.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6152");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6152");
    check_field_offset(lv, fb, 8, "STT6152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6152, STT6152)
//============================================================================


struct  STT6162  {
  float fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT6162) C1{ Fi Fs:3 Fi}



static void Test_STT6162()
{
  {
    init_simple_test("STT6162");
    static STRUCT_IF_C STT6162 lv;
    check2(sizeof(lv), 12, "sizeof(STT6162)");
    check2(__alignof__(lv), 4, "__alignof__(STT6162)");
    check_field_offset(lv, fa, 0, "STT6162.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6162");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6162");
    check_field_offset(lv, fb, 8, "STT6162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6162, STT6162)
//============================================================================


struct  STT6172  {
  float fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT6172) C1{ Fi Fi:3 Fi}



static void Test_STT6172()
{
  {
    init_simple_test("STT6172");
    static STRUCT_IF_C STT6172 lv;
    check2(sizeof(lv), 12, "sizeof(STT6172)");
    check2(__alignof__(lv), 4, "__alignof__(STT6172)");
    check_field_offset(lv, fa, 0, "STT6172.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6172");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6172");
    check_field_offset(lv, fb, 8, "STT6172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6172, STT6172)
//============================================================================


struct  STT6182  {
  float fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT6182) C1{ Fi FL:3 Fi}



static void Test_STT6182()
{
  {
    init_simple_test("STT6182");
    static STRUCT_IF_C STT6182 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6182)");
    check_field_offset(lv, fa, 0, "STT6182.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6182");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6182");
    check_field_offset(lv, fb, 8, "STT6182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6182, STT6182)
//============================================================================


struct  STT6192  {
  float fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT6192) C1{ Fi Fs:8 Fi}



static void Test_STT6192()
{
  {
    init_simple_test("STT6192");
    static STRUCT_IF_C STT6192 lv;
    check2(sizeof(lv), 12, "sizeof(STT6192)");
    check2(__alignof__(lv), 4, "__alignof__(STT6192)");
    check_field_offset(lv, fa, 0, "STT6192.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6192");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6192");
    check_field_offset(lv, fb, 8, "STT6192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6192, STT6192)
//============================================================================


struct  STT6202  {
  float fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT6202) C1{ Fi Fi:8 Fi}



static void Test_STT6202()
{
  {
    init_simple_test("STT6202");
    static STRUCT_IF_C STT6202 lv;
    check2(sizeof(lv), 12, "sizeof(STT6202)");
    check2(__alignof__(lv), 4, "__alignof__(STT6202)");
    check_field_offset(lv, fa, 0, "STT6202.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6202");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6202");
    check_field_offset(lv, fb, 8, "STT6202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6202, STT6202)
//============================================================================


struct  STT6212  {
  float fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT6212) C1{ Fi FL:8 Fi}



static void Test_STT6212()
{
  {
    init_simple_test("STT6212");
    static STRUCT_IF_C STT6212 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6212)");
    check_field_offset(lv, fa, 0, "STT6212.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6212");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6212");
    check_field_offset(lv, fb, 8, "STT6212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6212, STT6212)
//============================================================================


struct  STT6222  {
  float fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT6222) C1{ Fi Fi:18 Fi}



static void Test_STT6222()
{
  {
    init_simple_test("STT6222");
    static STRUCT_IF_C STT6222 lv;
    check2(sizeof(lv), 12, "sizeof(STT6222)");
    check2(__alignof__(lv), 4, "__alignof__(STT6222)");
    check_field_offset(lv, fa, 0, "STT6222.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6222");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6222");
    check_field_offset(lv, fb, 8, "STT6222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6222, STT6222)
//============================================================================


struct  STT6232  {
  float fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT6232) C1{ Fi FL:18 Fi}



static void Test_STT6232()
{
  {
    init_simple_test("STT6232");
    static STRUCT_IF_C STT6232 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6232)");
    check_field_offset(lv, fa, 0, "STT6232.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6232");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6232");
    check_field_offset(lv, fb, 8, "STT6232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6232, STT6232)
//============================================================================


struct  STT6242  {
  float fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT6242) C1{ Fi FL:48 Fi}



static void Test_STT6242()
{
  {
    init_simple_test("STT6242");
    static STRUCT_IF_C STT6242 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT6242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6242)");
    check_field_offset(lv, fa, 0, "STT6242.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6242");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6242");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6242, STT6242)
//============================================================================


struct  STT613  {
  float fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT613) C1{ Fi Fc:0 Fl}



static void Test_STT613()
{
  {
    init_simple_test("STT613");
    static STRUCT_IF_C STT613 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT613)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT613)");
    check_field_offset(lv, fa, 0, "STT613.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT613.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT613, STT613)
//============================================================================


struct  STT623  {
  float fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT623) C1{ Fi Fs:0 Fl}



static void Test_STT623()
{
  {
    init_simple_test("STT623");
    static STRUCT_IF_C STT623 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT623)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT623)");
    check_field_offset(lv, fa, 0, "STT623.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT623.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT623, STT623)
//============================================================================


struct  STT633  {
  float fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT633) C1{ Fi Fi:0 Fl}



static void Test_STT633()
{
  {
    init_simple_test("STT633");
    static STRUCT_IF_C STT633 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT633)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT633)");
    check_field_offset(lv, fa, 0, "STT633.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT633.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT633, STT633)
//============================================================================


struct  STT643  {
  float fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT643) C1{ Fi FL:0 Fl}



static void Test_STT643()
{
  {
    init_simple_test("STT643");
    static STRUCT_IF_C STT643 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT643)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT643)");
    check_field_offset(lv, fa, 0, "STT643.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT643.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT643, STT643)
//============================================================================


struct  STT653  {
  float fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT653) C1{ Fi Fc:3 Fl}



static void Test_STT653()
{
  {
    init_simple_test("STT653");
    static STRUCT_IF_C STT653 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT653)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT653)");
    check_field_offset(lv, fa, 0, "STT653.fa");
    check_field_offset(lv, fb, 8, "STT653.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT653, STT653)
//============================================================================


struct  STT663  {
  float fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT663) C1{ Fi Fs:3 Fl}



static void Test_STT663()
{
  {
    init_simple_test("STT663");
    static STRUCT_IF_C STT663 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT663)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT663)");
    check_field_offset(lv, fa, 0, "STT663.fa");
    check_field_offset(lv, fb, 8, "STT663.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT663, STT663)
//============================================================================


struct  STT673  {
  float fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT673) C1{ Fi Fi:3 Fl}



static void Test_STT673()
{
  {
    init_simple_test("STT673");
    static STRUCT_IF_C STT673 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT673)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT673)");
    check_field_offset(lv, fa, 0, "STT673.fa");
    check_field_offset(lv, fb, 8, "STT673.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT673, STT673)
//============================================================================


struct  STT683  {
  float fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT683) C1{ Fi FL:3 Fl}



static void Test_STT683()
{
  {
    init_simple_test("STT683");
    static STRUCT_IF_C STT683 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT683)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT683)");
    check_field_offset(lv, fa, 0, "STT683.fa");
    check_field_offset(lv, fb, 8, "STT683.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT683, STT683)
//============================================================================


struct  STT693  {
  float fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT693) C1{ Fi Fs:8 Fl}



static void Test_STT693()
{
  {
    init_simple_test("STT693");
    static STRUCT_IF_C STT693 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT693)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT693)");
    check_field_offset(lv, fa, 0, "STT693.fa");
    check_field_offset(lv, fb, 8, "STT693.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT693, STT693)
//============================================================================


struct  STT6103  {
  float fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT6103) C1{ Fi Fi:8 Fl}



static void Test_STT6103()
{
  {
    init_simple_test("STT6103");
    static STRUCT_IF_C STT6103 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6103)");
    check_field_offset(lv, fa, 0, "STT6103.fa");
    check_field_offset(lv, fb, 8, "STT6103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6103, STT6103)
//============================================================================


struct  STT6113  {
  float fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT6113) C1{ Fi FL:8 Fl}



static void Test_STT6113()
{
  {
    init_simple_test("STT6113");
    static STRUCT_IF_C STT6113 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6113)");
    check_field_offset(lv, fa, 0, "STT6113.fa");
    check_field_offset(lv, fb, 8, "STT6113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6113, STT6113)
//============================================================================


struct  STT6123  {
  float fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT6123) C1{ Fi Fi:18 Fl}



static void Test_STT6123()
{
  {
    init_simple_test("STT6123");
    static STRUCT_IF_C STT6123 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6123)");
    check_field_offset(lv, fa, 0, "STT6123.fa");
    check_field_offset(lv, fb, 8, "STT6123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6123, STT6123)
//============================================================================


struct  STT6133  {
  float fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT6133) C1{ Fi FL:18 Fl}



static void Test_STT6133()
{
  {
    init_simple_test("STT6133");
    static STRUCT_IF_C STT6133 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6133)");
    check_field_offset(lv, fa, 0, "STT6133.fa");
    check_field_offset(lv, fb, 8, "STT6133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6133, STT6133)
//============================================================================


struct  STT6143  {
  float fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT6143) C1{ Fi FL:48 Fl}



static void Test_STT6143()
{
  {
    init_simple_test("STT6143");
    static STRUCT_IF_C STT6143 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT6143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6143)");
    check_field_offset(lv, fa, 0, "STT6143.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6143, STT6143)
//============================================================================


struct  STT6153  {
  float fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT6153) C1{ Fi Fc:3 Fl}



static void Test_STT6153()
{
  {
    init_simple_test("STT6153");
    static STRUCT_IF_C STT6153 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6153)");
    check_field_offset(lv, fa, 0, "STT6153.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6153");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6153");
    check_field_offset(lv, fb, 8, "STT6153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6153, STT6153)
//============================================================================


struct  STT6163  {
  float fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT6163) C1{ Fi Fs:3 Fl}



static void Test_STT6163()
{
  {
    init_simple_test("STT6163");
    static STRUCT_IF_C STT6163 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6163)");
    check_field_offset(lv, fa, 0, "STT6163.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6163");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6163");
    check_field_offset(lv, fb, 8, "STT6163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6163, STT6163)
//============================================================================


struct  STT6173  {
  float fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT6173) C1{ Fi Fi:3 Fl}



static void Test_STT6173()
{
  {
    init_simple_test("STT6173");
    static STRUCT_IF_C STT6173 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6173)");
    check_field_offset(lv, fa, 0, "STT6173.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6173");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6173");
    check_field_offset(lv, fb, 8, "STT6173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6173, STT6173)
//============================================================================


struct  STT6183  {
  float fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT6183) C1{ Fi FL:3 Fl}



static void Test_STT6183()
{
  {
    init_simple_test("STT6183");
    static STRUCT_IF_C STT6183 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6183)");
    check_field_offset(lv, fa, 0, "STT6183.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6183");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6183");
    check_field_offset(lv, fb, 8, "STT6183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6183, STT6183)
//============================================================================


struct  STT6193  {
  float fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT6193) C1{ Fi Fs:8 Fl}



static void Test_STT6193()
{
  {
    init_simple_test("STT6193");
    static STRUCT_IF_C STT6193 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6193)");
    check_field_offset(lv, fa, 0, "STT6193.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6193");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6193");
    check_field_offset(lv, fb, 8, "STT6193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6193, STT6193)
//============================================================================


struct  STT6203  {
  float fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT6203) C1{ Fi Fi:8 Fl}



static void Test_STT6203()
{
  {
    init_simple_test("STT6203");
    static STRUCT_IF_C STT6203 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6203)");
    check_field_offset(lv, fa, 0, "STT6203.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6203");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6203");
    check_field_offset(lv, fb, 8, "STT6203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6203, STT6203)
//============================================================================


struct  STT6213  {
  float fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT6213) C1{ Fi FL:8 Fl}



static void Test_STT6213()
{
  {
    init_simple_test("STT6213");
    static STRUCT_IF_C STT6213 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6213)");
    check_field_offset(lv, fa, 0, "STT6213.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6213");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6213");
    check_field_offset(lv, fb, 8, "STT6213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6213, STT6213)
//============================================================================


struct  STT6223  {
  float fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT6223) C1{ Fi Fi:18 Fl}



static void Test_STT6223()
{
  {
    init_simple_test("STT6223");
    static STRUCT_IF_C STT6223 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6223)");
    check_field_offset(lv, fa, 0, "STT6223.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6223");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6223");
    check_field_offset(lv, fb, 8, "STT6223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6223, STT6223)
//============================================================================


struct  STT6233  {
  float fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT6233) C1{ Fi FL:18 Fl}



static void Test_STT6233()
{
  {
    init_simple_test("STT6233");
    static STRUCT_IF_C STT6233 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6233)");
    check_field_offset(lv, fa, 0, "STT6233.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6233");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6233");
    check_field_offset(lv, fb, 8, "STT6233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6233, STT6233)
//============================================================================


struct  STT6243  {
  float fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT6243) C1{ Fi FL:48 Fl}



static void Test_STT6243()
{
  {
    init_simple_test("STT6243");
    static STRUCT_IF_C STT6243 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT6243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6243)");
    check_field_offset(lv, fa, 0, "STT6243.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6243");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6243");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6243, STT6243)
//============================================================================


struct  STT614  {
  float fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT614) C1{ Fi Fc:0 FL}



static void Test_STT614()
{
  {
    init_simple_test("STT614");
    static STRUCT_IF_C STT614 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT614)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT614)");
    check_field_offset(lv, fa, 0, "STT614.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT614.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT614, STT614)
//============================================================================


struct  STT624  {
  float fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT624) C1{ Fi Fs:0 FL}



static void Test_STT624()
{
  {
    init_simple_test("STT624");
    static STRUCT_IF_C STT624 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT624)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT624)");
    check_field_offset(lv, fa, 0, "STT624.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT624.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT624, STT624)
//============================================================================


struct  STT634  {
  float fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT634) C1{ Fi Fi:0 FL}



static void Test_STT634()
{
  {
    init_simple_test("STT634");
    static STRUCT_IF_C STT634 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT634)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT634)");
    check_field_offset(lv, fa, 0, "STT634.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT634.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT634, STT634)
//============================================================================


struct  STT644  {
  float fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT644) C1{ Fi FL:0 FL}



static void Test_STT644()
{
  {
    init_simple_test("STT644");
    static STRUCT_IF_C STT644 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT644)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT644)");
    check_field_offset(lv, fa, 0, "STT644.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT644.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT644, STT644)
//============================================================================


struct  STT654  {
  float fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT654) C1{ Fi Fc:3 FL}



static void Test_STT654()
{
  {
    init_simple_test("STT654");
    static STRUCT_IF_C STT654 lv;
    check2(sizeof(lv), 16, "sizeof(STT654)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT654)");
    check_field_offset(lv, fa, 0, "STT654.fa");
    check_field_offset(lv, fb, 8, "STT654.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT654, STT654)
//============================================================================


struct  STT664  {
  float fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT664) C1{ Fi Fs:3 FL}



static void Test_STT664()
{
  {
    init_simple_test("STT664");
    static STRUCT_IF_C STT664 lv;
    check2(sizeof(lv), 16, "sizeof(STT664)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT664)");
    check_field_offset(lv, fa, 0, "STT664.fa");
    check_field_offset(lv, fb, 8, "STT664.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT664, STT664)
//============================================================================


struct  STT674  {
  float fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT674) C1{ Fi Fi:3 FL}



static void Test_STT674()
{
  {
    init_simple_test("STT674");
    static STRUCT_IF_C STT674 lv;
    check2(sizeof(lv), 16, "sizeof(STT674)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT674)");
    check_field_offset(lv, fa, 0, "STT674.fa");
    check_field_offset(lv, fb, 8, "STT674.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT674, STT674)
//============================================================================


struct  STT684  {
  float fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT684) C1{ Fi FL:3 FL}



static void Test_STT684()
{
  {
    init_simple_test("STT684");
    static STRUCT_IF_C STT684 lv;
    check2(sizeof(lv), 16, "sizeof(STT684)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT684)");
    check_field_offset(lv, fa, 0, "STT684.fa");
    check_field_offset(lv, fb, 8, "STT684.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT684, STT684)
//============================================================================


struct  STT694  {
  float fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT694) C1{ Fi Fs:8 FL}



static void Test_STT694()
{
  {
    init_simple_test("STT694");
    static STRUCT_IF_C STT694 lv;
    check2(sizeof(lv), 16, "sizeof(STT694)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT694)");
    check_field_offset(lv, fa, 0, "STT694.fa");
    check_field_offset(lv, fb, 8, "STT694.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT694, STT694)
//============================================================================


struct  STT6104  {
  float fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT6104) C1{ Fi Fi:8 FL}



static void Test_STT6104()
{
  {
    init_simple_test("STT6104");
    static STRUCT_IF_C STT6104 lv;
    check2(sizeof(lv), 16, "sizeof(STT6104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6104)");
    check_field_offset(lv, fa, 0, "STT6104.fa");
    check_field_offset(lv, fb, 8, "STT6104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6104, STT6104)
//============================================================================


struct  STT6114  {
  float fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT6114) C1{ Fi FL:8 FL}



static void Test_STT6114()
{
  {
    init_simple_test("STT6114");
    static STRUCT_IF_C STT6114 lv;
    check2(sizeof(lv), 16, "sizeof(STT6114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6114)");
    check_field_offset(lv, fa, 0, "STT6114.fa");
    check_field_offset(lv, fb, 8, "STT6114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6114, STT6114)
//============================================================================


struct  STT6124  {
  float fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT6124) C1{ Fi Fi:18 FL}



static void Test_STT6124()
{
  {
    init_simple_test("STT6124");
    static STRUCT_IF_C STT6124 lv;
    check2(sizeof(lv), 16, "sizeof(STT6124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6124)");
    check_field_offset(lv, fa, 0, "STT6124.fa");
    check_field_offset(lv, fb, 8, "STT6124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6124, STT6124)
//============================================================================


struct  STT6134  {
  float fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT6134) C1{ Fi FL:18 FL}



static void Test_STT6134()
{
  {
    init_simple_test("STT6134");
    static STRUCT_IF_C STT6134 lv;
    check2(sizeof(lv), 16, "sizeof(STT6134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6134)");
    check_field_offset(lv, fa, 0, "STT6134.fa");
    check_field_offset(lv, fb, 8, "STT6134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6134, STT6134)
//============================================================================


struct  STT6144  {
  float fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT6144) C1{ Fi FL:48 FL}



static void Test_STT6144()
{
  {
    init_simple_test("STT6144");
    static STRUCT_IF_C STT6144 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT6144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6144)");
    check_field_offset(lv, fa, 0, "STT6144.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6144, STT6144)
//============================================================================


struct  STT6154  {
  float fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT6154) C1{ Fi Fc:3 FL}



static void Test_STT6154()
{
  {
    init_simple_test("STT6154");
    static STRUCT_IF_C STT6154 lv;
    check2(sizeof(lv), 16, "sizeof(STT6154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6154)");
    check_field_offset(lv, fa, 0, "STT6154.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6154");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6154");
    check_field_offset(lv, fb, 8, "STT6154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6154, STT6154)
//============================================================================


struct  STT6164  {
  float fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT6164) C1{ Fi Fs:3 FL}



static void Test_STT6164()
{
  {
    init_simple_test("STT6164");
    static STRUCT_IF_C STT6164 lv;
    check2(sizeof(lv), 16, "sizeof(STT6164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6164)");
    check_field_offset(lv, fa, 0, "STT6164.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6164");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6164");
    check_field_offset(lv, fb, 8, "STT6164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6164, STT6164)
//============================================================================


struct  STT6174  {
  float fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT6174) C1{ Fi Fi:3 FL}



static void Test_STT6174()
{
  {
    init_simple_test("STT6174");
    static STRUCT_IF_C STT6174 lv;
    check2(sizeof(lv), 16, "sizeof(STT6174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6174)");
    check_field_offset(lv, fa, 0, "STT6174.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6174");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6174");
    check_field_offset(lv, fb, 8, "STT6174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6174, STT6174)
//============================================================================


struct  STT6184  {
  float fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT6184) C1{ Fi FL:3 FL}



static void Test_STT6184()
{
  {
    init_simple_test("STT6184");
    static STRUCT_IF_C STT6184 lv;
    check2(sizeof(lv), 16, "sizeof(STT6184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6184)");
    check_field_offset(lv, fa, 0, "STT6184.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6184");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6184");
    check_field_offset(lv, fb, 8, "STT6184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6184, STT6184)
//============================================================================


struct  STT6194  {
  float fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT6194) C1{ Fi Fs:8 FL}



static void Test_STT6194()
{
  {
    init_simple_test("STT6194");
    static STRUCT_IF_C STT6194 lv;
    check2(sizeof(lv), 16, "sizeof(STT6194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6194)");
    check_field_offset(lv, fa, 0, "STT6194.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6194");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6194");
    check_field_offset(lv, fb, 8, "STT6194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6194, STT6194)
//============================================================================


struct  STT6204  {
  float fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT6204) C1{ Fi Fi:8 FL}



static void Test_STT6204()
{
  {
    init_simple_test("STT6204");
    static STRUCT_IF_C STT6204 lv;
    check2(sizeof(lv), 16, "sizeof(STT6204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6204)");
    check_field_offset(lv, fa, 0, "STT6204.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6204");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6204");
    check_field_offset(lv, fb, 8, "STT6204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6204, STT6204)
//============================================================================


struct  STT6214  {
  float fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT6214) C1{ Fi FL:8 FL}



static void Test_STT6214()
{
  {
    init_simple_test("STT6214");
    static STRUCT_IF_C STT6214 lv;
    check2(sizeof(lv), 16, "sizeof(STT6214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6214)");
    check_field_offset(lv, fa, 0, "STT6214.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6214");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6214");
    check_field_offset(lv, fb, 8, "STT6214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6214, STT6214)
//============================================================================


struct  STT6224  {
  float fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT6224) C1{ Fi Fi:18 FL}



static void Test_STT6224()
{
  {
    init_simple_test("STT6224");
    static STRUCT_IF_C STT6224 lv;
    check2(sizeof(lv), 16, "sizeof(STT6224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6224)");
    check_field_offset(lv, fa, 0, "STT6224.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6224");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6224");
    check_field_offset(lv, fb, 8, "STT6224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6224, STT6224)
//============================================================================


struct  STT6234  {
  float fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT6234) C1{ Fi FL:18 FL}



static void Test_STT6234()
{
  {
    init_simple_test("STT6234");
    static STRUCT_IF_C STT6234 lv;
    check2(sizeof(lv), 16, "sizeof(STT6234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6234)");
    check_field_offset(lv, fa, 0, "STT6234.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6234");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6234");
    check_field_offset(lv, fb, 8, "STT6234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6234, STT6234)
//============================================================================


struct  STT6244  {
  float fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT6244) C1{ Fi FL:48 FL}



static void Test_STT6244()
{
  {
    init_simple_test("STT6244");
    static STRUCT_IF_C STT6244 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT6244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6244)");
    check_field_offset(lv, fa, 0, "STT6244.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6244");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6244");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6244, STT6244)
//============================================================================


struct  STT615  {
  float fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT615) C1{ Fi Fc:0 Fp}



static void Test_STT615()
{
  {
    init_simple_test("STT615");
    static STRUCT_IF_C STT615 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT615)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT615)");
    check_field_offset(lv, fa, 0, "STT615.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT615.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT615, STT615)
//============================================================================


struct  STT625  {
  float fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT625) C1{ Fi Fs:0 Fp}



static void Test_STT625()
{
  {
    init_simple_test("STT625");
    static STRUCT_IF_C STT625 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT625)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT625)");
    check_field_offset(lv, fa, 0, "STT625.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT625.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT625, STT625)
//============================================================================


struct  STT635  {
  float fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT635) C1{ Fi Fi:0 Fp}



static void Test_STT635()
{
  {
    init_simple_test("STT635");
    static STRUCT_IF_C STT635 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT635)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT635)");
    check_field_offset(lv, fa, 0, "STT635.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT635.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT635, STT635)
//============================================================================


struct  STT645  {
  float fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT645) C1{ Fi FL:0 Fp}



static void Test_STT645()
{
  {
    init_simple_test("STT645");
    static STRUCT_IF_C STT645 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT645)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT645)");
    check_field_offset(lv, fa, 0, "STT645.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT645.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT645, STT645)
//============================================================================


struct  STT655  {
  float fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT655) C1{ Fi Fc:3 Fp}



static void Test_STT655()
{
  {
    init_simple_test("STT655");
    static STRUCT_IF_C STT655 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT655)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT655)");
    check_field_offset(lv, fa, 0, "STT655.fa");
    check_field_offset(lv, fb, 8, "STT655.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT655, STT655)
//============================================================================


struct  STT665  {
  float fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT665) C1{ Fi Fs:3 Fp}



static void Test_STT665()
{
  {
    init_simple_test("STT665");
    static STRUCT_IF_C STT665 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT665)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT665)");
    check_field_offset(lv, fa, 0, "STT665.fa");
    check_field_offset(lv, fb, 8, "STT665.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT665, STT665)
//============================================================================


struct  STT675  {
  float fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT675) C1{ Fi Fi:3 Fp}



static void Test_STT675()
{
  {
    init_simple_test("STT675");
    static STRUCT_IF_C STT675 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT675)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT675)");
    check_field_offset(lv, fa, 0, "STT675.fa");
    check_field_offset(lv, fb, 8, "STT675.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT675, STT675)
//============================================================================


struct  STT685  {
  float fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT685) C1{ Fi FL:3 Fp}



static void Test_STT685()
{
  {
    init_simple_test("STT685");
    static STRUCT_IF_C STT685 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT685)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT685)");
    check_field_offset(lv, fa, 0, "STT685.fa");
    check_field_offset(lv, fb, 8, "STT685.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT685, STT685)
//============================================================================


struct  STT695  {
  float fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT695) C1{ Fi Fs:8 Fp}



static void Test_STT695()
{
  {
    init_simple_test("STT695");
    static STRUCT_IF_C STT695 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT695)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT695)");
    check_field_offset(lv, fa, 0, "STT695.fa");
    check_field_offset(lv, fb, 8, "STT695.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT695, STT695)
//============================================================================


struct  STT6105  {
  float fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT6105) C1{ Fi Fi:8 Fp}



static void Test_STT6105()
{
  {
    init_simple_test("STT6105");
    static STRUCT_IF_C STT6105 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6105)");
    check_field_offset(lv, fa, 0, "STT6105.fa");
    check_field_offset(lv, fb, 8, "STT6105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6105, STT6105)
//============================================================================


struct  STT6115  {
  float fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT6115) C1{ Fi FL:8 Fp}



static void Test_STT6115()
{
  {
    init_simple_test("STT6115");
    static STRUCT_IF_C STT6115 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6115)");
    check_field_offset(lv, fa, 0, "STT6115.fa");
    check_field_offset(lv, fb, 8, "STT6115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6115, STT6115)
//============================================================================


struct  STT6125  {
  float fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT6125) C1{ Fi Fi:18 Fp}



static void Test_STT6125()
{
  {
    init_simple_test("STT6125");
    static STRUCT_IF_C STT6125 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6125)");
    check_field_offset(lv, fa, 0, "STT6125.fa");
    check_field_offset(lv, fb, 8, "STT6125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6125, STT6125)
//============================================================================


struct  STT6135  {
  float fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT6135) C1{ Fi FL:18 Fp}



static void Test_STT6135()
{
  {
    init_simple_test("STT6135");
    static STRUCT_IF_C STT6135 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6135)");
    check_field_offset(lv, fa, 0, "STT6135.fa");
    check_field_offset(lv, fb, 8, "STT6135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6135, STT6135)
//============================================================================


struct  STT6145  {
  float fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT6145) C1{ Fi FL:48 Fp}



static void Test_STT6145()
{
  {
    init_simple_test("STT6145");
    static STRUCT_IF_C STT6145 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT6145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6145)");
    check_field_offset(lv, fa, 0, "STT6145.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6145, STT6145)
//============================================================================


struct  STT6155  {
  float fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT6155) C1{ Fi Fc:3 Fp}



static void Test_STT6155()
{
  {
    init_simple_test("STT6155");
    static STRUCT_IF_C STT6155 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6155)");
    check_field_offset(lv, fa, 0, "STT6155.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6155");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6155");
    check_field_offset(lv, fb, 8, "STT6155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6155, STT6155)
//============================================================================


struct  STT6165  {
  float fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT6165) C1{ Fi Fs:3 Fp}



static void Test_STT6165()
{
  {
    init_simple_test("STT6165");
    static STRUCT_IF_C STT6165 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6165)");
    check_field_offset(lv, fa, 0, "STT6165.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6165");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6165");
    check_field_offset(lv, fb, 8, "STT6165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6165, STT6165)
//============================================================================


struct  STT6175  {
  float fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT6175) C1{ Fi Fi:3 Fp}



static void Test_STT6175()
{
  {
    init_simple_test("STT6175");
    static STRUCT_IF_C STT6175 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6175)");
    check_field_offset(lv, fa, 0, "STT6175.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6175");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6175");
    check_field_offset(lv, fb, 8, "STT6175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6175, STT6175)
//============================================================================


struct  STT6185  {
  float fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT6185) C1{ Fi FL:3 Fp}



static void Test_STT6185()
{
  {
    init_simple_test("STT6185");
    static STRUCT_IF_C STT6185 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6185)");
    check_field_offset(lv, fa, 0, "STT6185.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6185");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6185");
    check_field_offset(lv, fb, 8, "STT6185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6185, STT6185)
//============================================================================


struct  STT6195  {
  float fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT6195) C1{ Fi Fs:8 Fp}



static void Test_STT6195()
{
  {
    init_simple_test("STT6195");
    static STRUCT_IF_C STT6195 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6195)");
    check_field_offset(lv, fa, 0, "STT6195.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6195");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6195");
    check_field_offset(lv, fb, 8, "STT6195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6195, STT6195)
//============================================================================


struct  STT6205  {
  float fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT6205) C1{ Fi Fi:8 Fp}



static void Test_STT6205()
{
  {
    init_simple_test("STT6205");
    static STRUCT_IF_C STT6205 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6205)");
    check_field_offset(lv, fa, 0, "STT6205.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6205");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6205");
    check_field_offset(lv, fb, 8, "STT6205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6205, STT6205)
//============================================================================


struct  STT6215  {
  float fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT6215) C1{ Fi FL:8 Fp}



static void Test_STT6215()
{
  {
    init_simple_test("STT6215");
    static STRUCT_IF_C STT6215 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6215)");
    check_field_offset(lv, fa, 0, "STT6215.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6215");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6215");
    check_field_offset(lv, fb, 8, "STT6215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6215, STT6215)
//============================================================================


struct  STT6225  {
  float fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT6225) C1{ Fi Fi:18 Fp}



static void Test_STT6225()
{
  {
    init_simple_test("STT6225");
    static STRUCT_IF_C STT6225 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6225)");
    check_field_offset(lv, fa, 0, "STT6225.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6225");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6225");
    check_field_offset(lv, fb, 8, "STT6225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6225, STT6225)
//============================================================================


struct  STT6235  {
  float fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT6235) C1{ Fi FL:18 Fp}



static void Test_STT6235()
{
  {
    init_simple_test("STT6235");
    static STRUCT_IF_C STT6235 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6235)");
    check_field_offset(lv, fa, 0, "STT6235.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6235");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6235");
    check_field_offset(lv, fb, 8, "STT6235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6235, STT6235)
//============================================================================


struct  STT6245  {
  float fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT6245) C1{ Fi FL:48 Fp}



static void Test_STT6245()
{
  {
    init_simple_test("STT6245");
    static STRUCT_IF_C STT6245 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT6245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6245)");
    check_field_offset(lv, fa, 0, "STT6245.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6245");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6245");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6245, STT6245)
//============================================================================


struct  STT616  {
  float fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT616) C1{ Fi Fc:0 Fi}



static void Test_STT616()
{
  {
    init_simple_test("STT616");
    static STRUCT_IF_C STT616 lv;
    check2(sizeof(lv), 8, "sizeof(STT616)");
    check2(__alignof__(lv), 4, "__alignof__(STT616)");
    check_field_offset(lv, fa, 0, "STT616.fa");
    check_field_offset(lv, fb, 4, "STT616.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT616, STT616)
//============================================================================


struct  STT626  {
  float fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT626) C1{ Fi Fs:0 Fi}



static void Test_STT626()
{
  {
    init_simple_test("STT626");
    static STRUCT_IF_C STT626 lv;
    check2(sizeof(lv), 8, "sizeof(STT626)");
    check2(__alignof__(lv), 4, "__alignof__(STT626)");
    check_field_offset(lv, fa, 0, "STT626.fa");
    check_field_offset(lv, fb, 4, "STT626.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT626, STT626)
//============================================================================


struct  STT636  {
  float fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT636) C1{ Fi Fi:0 Fi}



static void Test_STT636()
{
  {
    init_simple_test("STT636");
    static STRUCT_IF_C STT636 lv;
    check2(sizeof(lv), 8, "sizeof(STT636)");
    check2(__alignof__(lv), 4, "__alignof__(STT636)");
    check_field_offset(lv, fa, 0, "STT636.fa");
    check_field_offset(lv, fb, 4, "STT636.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT636, STT636)
//============================================================================


struct  STT646  {
  float fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT646) C1{ Fi FL:0 Fi}



static void Test_STT646()
{
  {
    init_simple_test("STT646");
    static STRUCT_IF_C STT646 lv;
    check2(sizeof(lv), ABISELECT(12,8), "sizeof(STT646)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT646)");
    check_field_offset(lv, fa, 0, "STT646.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT646.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT646, STT646)
//============================================================================


struct  STT656  {
  float fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT656) C1{ Fi Fc:3 Fi}



static void Test_STT656()
{
  {
    init_simple_test("STT656");
    static STRUCT_IF_C STT656 lv;
    check2(sizeof(lv), 12, "sizeof(STT656)");
    check2(__alignof__(lv), 4, "__alignof__(STT656)");
    check_field_offset(lv, fa, 0, "STT656.fa");
    check_field_offset(lv, fb, 8, "STT656.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT656, STT656)
//============================================================================


struct  STT666  {
  float fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT666) C1{ Fi Fs:3 Fi}



static void Test_STT666()
{
  {
    init_simple_test("STT666");
    static STRUCT_IF_C STT666 lv;
    check2(sizeof(lv), 12, "sizeof(STT666)");
    check2(__alignof__(lv), 4, "__alignof__(STT666)");
    check_field_offset(lv, fa, 0, "STT666.fa");
    check_field_offset(lv, fb, 8, "STT666.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT666, STT666)
//============================================================================


struct  STT676  {
  float fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT676) C1{ Fi Fi:3 Fi}



static void Test_STT676()
{
  {
    init_simple_test("STT676");
    static STRUCT_IF_C STT676 lv;
    check2(sizeof(lv), 12, "sizeof(STT676)");
    check2(__alignof__(lv), 4, "__alignof__(STT676)");
    check_field_offset(lv, fa, 0, "STT676.fa");
    check_field_offset(lv, fb, 8, "STT676.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT676, STT676)
//============================================================================


struct  STT686  {
  float fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT686) C1{ Fi FL:3 Fi}



static void Test_STT686()
{
  {
    init_simple_test("STT686");
    static STRUCT_IF_C STT686 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT686)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT686)");
    check_field_offset(lv, fa, 0, "STT686.fa");
    check_field_offset(lv, fb, 8, "STT686.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT686, STT686)
//============================================================================


struct  STT696  {
  float fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT696) C1{ Fi Fs:8 Fi}



static void Test_STT696()
{
  {
    init_simple_test("STT696");
    static STRUCT_IF_C STT696 lv;
    check2(sizeof(lv), 12, "sizeof(STT696)");
    check2(__alignof__(lv), 4, "__alignof__(STT696)");
    check_field_offset(lv, fa, 0, "STT696.fa");
    check_field_offset(lv, fb, 8, "STT696.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT696, STT696)
//============================================================================


struct  STT6106  {
  float fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT6106) C1{ Fi Fi:8 Fi}



static void Test_STT6106()
{
  {
    init_simple_test("STT6106");
    static STRUCT_IF_C STT6106 lv;
    check2(sizeof(lv), 12, "sizeof(STT6106)");
    check2(__alignof__(lv), 4, "__alignof__(STT6106)");
    check_field_offset(lv, fa, 0, "STT6106.fa");
    check_field_offset(lv, fb, 8, "STT6106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6106, STT6106)
//============================================================================


struct  STT6116  {
  float fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT6116) C1{ Fi FL:8 Fi}



static void Test_STT6116()
{
  {
    init_simple_test("STT6116");
    static STRUCT_IF_C STT6116 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT6116)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6116)");
    check_field_offset(lv, fa, 0, "STT6116.fa");
    check_field_offset(lv, fb, 8, "STT6116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6116, STT6116)
//============================================================================


struct  STT6126  {
  float fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT6126) C1{ Fi Fi:18 Fi}



static void Test_STT6126()
{
  {
    init_simple_test("STT6126");
    static STRUCT_IF_C STT6126 lv;
    check2(sizeof(lv), 12, "sizeof(STT6126)");
    check2(__alignof__(lv), 4, "__alignof__(STT6126)");
    check_field_offset(lv, fa, 0, "STT6126.fa");
    check_field_offset(lv, fb, 8, "STT6126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6126, STT6126)
//============================================================================


struct  STT6136  {
  float fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT6136) C1{ Fi FL:18 Fi}



static void Test_STT6136()
{
  {
    init_simple_test("STT6136");
    static STRUCT_IF_C STT6136 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT6136)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6136)");
    check_field_offset(lv, fa, 0, "STT6136.fa");
    check_field_offset(lv, fb, 8, "STT6136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6136, STT6136)
//============================================================================


struct  STT6146  {
  float fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT6146) C1{ Fi FL:48 Fi}



static void Test_STT6146()
{
  {
    init_simple_test("STT6146");
    static STRUCT_IF_C STT6146 lv;
    check2(sizeof(lv), ABISELECT(20,16), "sizeof(STT6146)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6146)");
    check_field_offset(lv, fa, 0, "STT6146.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6146, STT6146)
//============================================================================


struct  STT6156  {
  float fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT6156) C1{ Fi Fc:3 Fi}



static void Test_STT6156()
{
  {
    init_simple_test("STT6156");
    static STRUCT_IF_C STT6156 lv;
    check2(sizeof(lv), 12, "sizeof(STT6156)");
    check2(__alignof__(lv), 4, "__alignof__(STT6156)");
    check_field_offset(lv, fa, 0, "STT6156.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6156");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6156");
    check_field_offset(lv, fb, 8, "STT6156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6156, STT6156)
//============================================================================


struct  STT6166  {
  float fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT6166) C1{ Fi Fs:3 Fi}



static void Test_STT6166()
{
  {
    init_simple_test("STT6166");
    static STRUCT_IF_C STT6166 lv;
    check2(sizeof(lv), 12, "sizeof(STT6166)");
    check2(__alignof__(lv), 4, "__alignof__(STT6166)");
    check_field_offset(lv, fa, 0, "STT6166.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6166");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6166");
    check_field_offset(lv, fb, 8, "STT6166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6166, STT6166)
//============================================================================


struct  STT6176  {
  float fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT6176) C1{ Fi Fi:3 Fi}



static void Test_STT6176()
{
  {
    init_simple_test("STT6176");
    static STRUCT_IF_C STT6176 lv;
    check2(sizeof(lv), 12, "sizeof(STT6176)");
    check2(__alignof__(lv), 4, "__alignof__(STT6176)");
    check_field_offset(lv, fa, 0, "STT6176.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6176");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6176");
    check_field_offset(lv, fb, 8, "STT6176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6176, STT6176)
//============================================================================


struct  STT6186  {
  float fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT6186) C1{ Fi FL:3 Fi}



static void Test_STT6186()
{
  {
    init_simple_test("STT6186");
    static STRUCT_IF_C STT6186 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6186)");
    check_field_offset(lv, fa, 0, "STT6186.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6186");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6186");
    check_field_offset(lv, fb, 8, "STT6186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6186, STT6186)
//============================================================================


struct  STT6196  {
  float fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT6196) C1{ Fi Fs:8 Fi}



static void Test_STT6196()
{
  {
    init_simple_test("STT6196");
    static STRUCT_IF_C STT6196 lv;
    check2(sizeof(lv), 12, "sizeof(STT6196)");
    check2(__alignof__(lv), 4, "__alignof__(STT6196)");
    check_field_offset(lv, fa, 0, "STT6196.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6196");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6196");
    check_field_offset(lv, fb, 8, "STT6196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6196, STT6196)
//============================================================================


struct  STT6206  {
  float fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT6206) C1{ Fi Fi:8 Fi}



static void Test_STT6206()
{
  {
    init_simple_test("STT6206");
    static STRUCT_IF_C STT6206 lv;
    check2(sizeof(lv), 12, "sizeof(STT6206)");
    check2(__alignof__(lv), 4, "__alignof__(STT6206)");
    check_field_offset(lv, fa, 0, "STT6206.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6206");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6206");
    check_field_offset(lv, fb, 8, "STT6206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6206, STT6206)
//============================================================================


struct  STT6216  {
  float fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT6216) C1{ Fi FL:8 Fi}



static void Test_STT6216()
{
  {
    init_simple_test("STT6216");
    static STRUCT_IF_C STT6216 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6216)");
    check_field_offset(lv, fa, 0, "STT6216.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6216");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6216");
    check_field_offset(lv, fb, 8, "STT6216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6216, STT6216)
//============================================================================


struct  STT6226  {
  float fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT6226) C1{ Fi Fi:18 Fi}



static void Test_STT6226()
{
  {
    init_simple_test("STT6226");
    static STRUCT_IF_C STT6226 lv;
    check2(sizeof(lv), 12, "sizeof(STT6226)");
    check2(__alignof__(lv), 4, "__alignof__(STT6226)");
    check_field_offset(lv, fa, 0, "STT6226.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6226");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6226");
    check_field_offset(lv, fb, 8, "STT6226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6226, STT6226)
//============================================================================


struct  STT6236  {
  float fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT6236) C1{ Fi FL:18 Fi}



static void Test_STT6236()
{
  {
    init_simple_test("STT6236");
    static STRUCT_IF_C STT6236 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6236)");
    check_field_offset(lv, fa, 0, "STT6236.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6236");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6236");
    check_field_offset(lv, fb, 8, "STT6236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6236, STT6236)
//============================================================================


struct  STT6246  {
  float fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT6246) C1{ Fi FL:48 Fi}



static void Test_STT6246()
{
  {
    init_simple_test("STT6246");
    static STRUCT_IF_C STT6246 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT6246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6246)");
    check_field_offset(lv, fa, 0, "STT6246.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6246");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6246");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6246, STT6246)
//============================================================================


struct  STT617  {
  float fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT617) C1{ Fi Fc:0 FL}



static void Test_STT617()
{
  {
    init_simple_test("STT617");
    static STRUCT_IF_C STT617 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT617)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT617)");
    check_field_offset(lv, fa, 0, "STT617.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT617.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT617, STT617)
//============================================================================


struct  STT627  {
  float fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT627) C1{ Fi Fs:0 FL}



static void Test_STT627()
{
  {
    init_simple_test("STT627");
    static STRUCT_IF_C STT627 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT627)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT627)");
    check_field_offset(lv, fa, 0, "STT627.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT627.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT627, STT627)
//============================================================================


struct  STT637  {
  float fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT637) C1{ Fi Fi:0 FL}



static void Test_STT637()
{
  {
    init_simple_test("STT637");
    static STRUCT_IF_C STT637 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT637)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT637)");
    check_field_offset(lv, fa, 0, "STT637.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT637.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT637, STT637)
//============================================================================


struct  STT647  {
  float fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT647) C1{ Fi FL:0 FL}



static void Test_STT647()
{
  {
    init_simple_test("STT647");
    static STRUCT_IF_C STT647 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT647)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT647)");
    check_field_offset(lv, fa, 0, "STT647.fa");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT647.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT647, STT647)
//============================================================================


struct  STT657  {
  float fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT657) C1{ Fi Fc:3 FL}



static void Test_STT657()
{
  {
    init_simple_test("STT657");
    static STRUCT_IF_C STT657 lv;
    check2(sizeof(lv), 16, "sizeof(STT657)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT657)");
    check_field_offset(lv, fa, 0, "STT657.fa");
    check_field_offset(lv, fb, 8, "STT657.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT657, STT657)
//============================================================================


struct  STT667  {
  float fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT667) C1{ Fi Fs:3 FL}



static void Test_STT667()
{
  {
    init_simple_test("STT667");
    static STRUCT_IF_C STT667 lv;
    check2(sizeof(lv), 16, "sizeof(STT667)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT667)");
    check_field_offset(lv, fa, 0, "STT667.fa");
    check_field_offset(lv, fb, 8, "STT667.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT667, STT667)
//============================================================================


struct  STT677  {
  float fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT677) C1{ Fi Fi:3 FL}



static void Test_STT677()
{
  {
    init_simple_test("STT677");
    static STRUCT_IF_C STT677 lv;
    check2(sizeof(lv), 16, "sizeof(STT677)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT677)");
    check_field_offset(lv, fa, 0, "STT677.fa");
    check_field_offset(lv, fb, 8, "STT677.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT677, STT677)
//============================================================================


struct  STT687  {
  float fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT687) C1{ Fi FL:3 FL}



static void Test_STT687()
{
  {
    init_simple_test("STT687");
    static STRUCT_IF_C STT687 lv;
    check2(sizeof(lv), 16, "sizeof(STT687)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT687)");
    check_field_offset(lv, fa, 0, "STT687.fa");
    check_field_offset(lv, fb, 8, "STT687.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT687, STT687)
//============================================================================


struct  STT697  {
  float fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT697) C1{ Fi Fs:8 FL}



static void Test_STT697()
{
  {
    init_simple_test("STT697");
    static STRUCT_IF_C STT697 lv;
    check2(sizeof(lv), 16, "sizeof(STT697)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT697)");
    check_field_offset(lv, fa, 0, "STT697.fa");
    check_field_offset(lv, fb, 8, "STT697.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT697, STT697)
//============================================================================


struct  STT6107  {
  float fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT6107) C1{ Fi Fi:8 FL}



static void Test_STT6107()
{
  {
    init_simple_test("STT6107");
    static STRUCT_IF_C STT6107 lv;
    check2(sizeof(lv), 16, "sizeof(STT6107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6107)");
    check_field_offset(lv, fa, 0, "STT6107.fa");
    check_field_offset(lv, fb, 8, "STT6107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6107, STT6107)
//============================================================================


struct  STT6117  {
  float fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT6117) C1{ Fi FL:8 FL}



static void Test_STT6117()
{
  {
    init_simple_test("STT6117");
    static STRUCT_IF_C STT6117 lv;
    check2(sizeof(lv), 16, "sizeof(STT6117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6117)");
    check_field_offset(lv, fa, 0, "STT6117.fa");
    check_field_offset(lv, fb, 8, "STT6117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6117, STT6117)
//============================================================================


struct  STT6127  {
  float fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT6127) C1{ Fi Fi:18 FL}



static void Test_STT6127()
{
  {
    init_simple_test("STT6127");
    static STRUCT_IF_C STT6127 lv;
    check2(sizeof(lv), 16, "sizeof(STT6127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6127)");
    check_field_offset(lv, fa, 0, "STT6127.fa");
    check_field_offset(lv, fb, 8, "STT6127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6127, STT6127)
//============================================================================


struct  STT6137  {
  float fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT6137) C1{ Fi FL:18 FL}



static void Test_STT6137()
{
  {
    init_simple_test("STT6137");
    static STRUCT_IF_C STT6137 lv;
    check2(sizeof(lv), 16, "sizeof(STT6137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6137)");
    check_field_offset(lv, fa, 0, "STT6137.fa");
    check_field_offset(lv, fb, 8, "STT6137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6137, STT6137)
//============================================================================


struct  STT6147  {
  float fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT6147) C1{ Fi FL:48 FL}



static void Test_STT6147()
{
  {
    init_simple_test("STT6147");
    static STRUCT_IF_C STT6147 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT6147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6147)");
    check_field_offset(lv, fa, 0, "STT6147.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6147, STT6147)
//============================================================================


struct  STT6157  {
  float fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT6157) C1{ Fi Fc:3 FL}



static void Test_STT6157()
{
  {
    init_simple_test("STT6157");
    static STRUCT_IF_C STT6157 lv;
    check2(sizeof(lv), 16, "sizeof(STT6157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6157)");
    check_field_offset(lv, fa, 0, "STT6157.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6157");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6157");
    check_field_offset(lv, fb, 8, "STT6157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6157, STT6157)
//============================================================================


struct  STT6167  {
  float fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT6167) C1{ Fi Fs:3 FL}



static void Test_STT6167()
{
  {
    init_simple_test("STT6167");
    static STRUCT_IF_C STT6167 lv;
    check2(sizeof(lv), 16, "sizeof(STT6167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6167)");
    check_field_offset(lv, fa, 0, "STT6167.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6167");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6167");
    check_field_offset(lv, fb, 8, "STT6167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6167, STT6167)
//============================================================================


struct  STT6177  {
  float fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT6177) C1{ Fi Fi:3 FL}



static void Test_STT6177()
{
  {
    init_simple_test("STT6177");
    static STRUCT_IF_C STT6177 lv;
    check2(sizeof(lv), 16, "sizeof(STT6177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6177)");
    check_field_offset(lv, fa, 0, "STT6177.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6177");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6177");
    check_field_offset(lv, fb, 8, "STT6177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6177, STT6177)
//============================================================================


struct  STT6187  {
  float fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT6187) C1{ Fi FL:3 FL}



static void Test_STT6187()
{
  {
    init_simple_test("STT6187");
    static STRUCT_IF_C STT6187 lv;
    check2(sizeof(lv), 16, "sizeof(STT6187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6187)");
    check_field_offset(lv, fa, 0, "STT6187.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6187");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6187");
    check_field_offset(lv, fb, 8, "STT6187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6187, STT6187)
//============================================================================


struct  STT6197  {
  float fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT6197) C1{ Fi Fs:8 FL}



static void Test_STT6197()
{
  {
    init_simple_test("STT6197");
    static STRUCT_IF_C STT6197 lv;
    check2(sizeof(lv), 16, "sizeof(STT6197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6197)");
    check_field_offset(lv, fa, 0, "STT6197.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6197");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6197");
    check_field_offset(lv, fb, 8, "STT6197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6197, STT6197)
//============================================================================


struct  STT6207  {
  float fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT6207) C1{ Fi Fi:8 FL}



static void Test_STT6207()
{
  {
    init_simple_test("STT6207");
    static STRUCT_IF_C STT6207 lv;
    check2(sizeof(lv), 16, "sizeof(STT6207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6207)");
    check_field_offset(lv, fa, 0, "STT6207.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6207");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6207");
    check_field_offset(lv, fb, 8, "STT6207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6207, STT6207)
//============================================================================


struct  STT6217  {
  float fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT6217) C1{ Fi FL:8 FL}



static void Test_STT6217()
{
  {
    init_simple_test("STT6217");
    static STRUCT_IF_C STT6217 lv;
    check2(sizeof(lv), 16, "sizeof(STT6217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6217)");
    check_field_offset(lv, fa, 0, "STT6217.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6217");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6217");
    check_field_offset(lv, fb, 8, "STT6217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6217, STT6217)
//============================================================================


struct  STT6227  {
  float fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT6227) C1{ Fi Fi:18 FL}



static void Test_STT6227()
{
  {
    init_simple_test("STT6227");
    static STRUCT_IF_C STT6227 lv;
    check2(sizeof(lv), 16, "sizeof(STT6227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6227)");
    check_field_offset(lv, fa, 0, "STT6227.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6227");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6227");
    check_field_offset(lv, fb, 8, "STT6227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6227, STT6227)
//============================================================================


struct  STT6237  {
  float fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT6237) C1{ Fi FL:18 FL}



static void Test_STT6237()
{
  {
    init_simple_test("STT6237");
    static STRUCT_IF_C STT6237 lv;
    check2(sizeof(lv), 16, "sizeof(STT6237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6237)");
    check_field_offset(lv, fa, 0, "STT6237.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6237");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6237");
    check_field_offset(lv, fb, 8, "STT6237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6237, STT6237)
//============================================================================


struct  STT6247  {
  float fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT6247) C1{ Fi FL:48 FL}



static void Test_STT6247()
{
  {
    init_simple_test("STT6247");
    static STRUCT_IF_C STT6247 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT6247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6247)");
    check_field_offset(lv, fa, 0, "STT6247.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6247");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6247");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6247, STT6247)
//============================================================================


struct  STT618  {
  float fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT618) C1{ Fi Fc:0 FD}



static void Test_STT618()
{
  {
    init_simple_test("STT618");
    static STRUCT_IF_C STT618 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT618)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT618)");
    check_field_offset(lv, fa, 0, "STT618.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT618.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT618, STT618)
//============================================================================


struct  STT628  {
  float fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT628) C1{ Fi Fs:0 FD}



static void Test_STT628()
{
  {
    init_simple_test("STT628");
    static STRUCT_IF_C STT628 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT628)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT628)");
    check_field_offset(lv, fa, 0, "STT628.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT628.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT628, STT628)
//============================================================================


struct  STT638  {
  float fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT638) C1{ Fi Fi:0 FD}



static void Test_STT638()
{
  {
    init_simple_test("STT638");
    static STRUCT_IF_C STT638 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT638)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT638)");
    check_field_offset(lv, fa, 0, "STT638.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT638.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT638, STT638)
//============================================================================


struct  STT648  {
  float fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT648) C1{ Fi FL:0 FD}



static void Test_STT648()
{
  {
    init_simple_test("STT648");
    static STRUCT_IF_C STT648 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT648)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT648)");
    check_field_offset(lv, fa, 0, "STT648.fa");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT648.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT648, STT648)
//============================================================================


struct  STT658  {
  float fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT658) C1{ Fi Fc:3 FD}



static void Test_STT658()
{
  {
    init_simple_test("STT658");
    static STRUCT_IF_C STT658 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT658)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT658)");
    check_field_offset(lv, fa, 0, "STT658.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT658.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT658, STT658)
//============================================================================


struct  STT668  {
  float fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT668) C1{ Fi Fs:3 FD}



static void Test_STT668()
{
  {
    init_simple_test("STT668");
    static STRUCT_IF_C STT668 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT668)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT668)");
    check_field_offset(lv, fa, 0, "STT668.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT668.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT668, STT668)
//============================================================================


struct  STT678  {
  float fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT678) C1{ Fi Fi:3 FD}



static void Test_STT678()
{
  {
    init_simple_test("STT678");
    static STRUCT_IF_C STT678 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT678)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT678)");
    check_field_offset(lv, fa, 0, "STT678.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT678.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT678, STT678)
//============================================================================


struct  STT688  {
  float fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT688) C1{ Fi FL:3 FD}



static void Test_STT688()
{
  {
    init_simple_test("STT688");
    static STRUCT_IF_C STT688 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT688)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT688)");
    check_field_offset(lv, fa, 0, "STT688.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT688.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT688, STT688)
//============================================================================


struct  STT698  {
  float fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT698) C1{ Fi Fs:8 FD}



static void Test_STT698()
{
  {
    init_simple_test("STT698");
    static STRUCT_IF_C STT698 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT698)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT698)");
    check_field_offset(lv, fa, 0, "STT698.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT698.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT698, STT698)
//============================================================================


struct  STT6108  {
  float fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT6108) C1{ Fi Fi:8 FD}



static void Test_STT6108()
{
  {
    init_simple_test("STT6108");
    static STRUCT_IF_C STT6108 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6108)");
    check_field_offset(lv, fa, 0, "STT6108.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6108, STT6108)
//============================================================================


struct  STT6118  {
  float fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT6118) C1{ Fi FL:8 FD}



static void Test_STT6118()
{
  {
    init_simple_test("STT6118");
    static STRUCT_IF_C STT6118 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6118)");
    check_field_offset(lv, fa, 0, "STT6118.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6118, STT6118)
//============================================================================


struct  STT6128  {
  float fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT6128) C1{ Fi Fi:18 FD}



static void Test_STT6128()
{
  {
    init_simple_test("STT6128");
    static STRUCT_IF_C STT6128 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6128)");
    check_field_offset(lv, fa, 0, "STT6128.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6128, STT6128)
//============================================================================


struct  STT6138  {
  float fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT6138) C1{ Fi FL:18 FD}



static void Test_STT6138()
{
  {
    init_simple_test("STT6138");
    static STRUCT_IF_C STT6138 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6138)");
    check_field_offset(lv, fa, 0, "STT6138.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6138, STT6138)
//============================================================================


struct  STT6148  {
  float fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT6148) C1{ Fi FL:48 FD}



static void Test_STT6148()
{
  {
    init_simple_test("STT6148");
    static STRUCT_IF_C STT6148 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT6148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6148)");
    check_field_offset(lv, fa, 0, "STT6148.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6148, STT6148)
//============================================================================


struct  STT6158  {
  float fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT6158) C1{ Fi Fc:3 FD}



static void Test_STT6158()
{
  {
    init_simple_test("STT6158");
    static STRUCT_IF_C STT6158 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6158)");
    check_field_offset(lv, fa, 0, "STT6158.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6158");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6158");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6158, STT6158)
//============================================================================


struct  STT6168  {
  float fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT6168) C1{ Fi Fs:3 FD}



static void Test_STT6168()
{
  {
    init_simple_test("STT6168");
    static STRUCT_IF_C STT6168 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6168)");
    check_field_offset(lv, fa, 0, "STT6168.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6168");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6168");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6168, STT6168)
//============================================================================


struct  STT6178  {
  float fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT6178) C1{ Fi Fi:3 FD}



static void Test_STT6178()
{
  {
    init_simple_test("STT6178");
    static STRUCT_IF_C STT6178 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6178)");
    check_field_offset(lv, fa, 0, "STT6178.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6178");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6178");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6178, STT6178)
//============================================================================


struct  STT6188  {
  float fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT6188) C1{ Fi FL:3 FD}



static void Test_STT6188()
{
  {
    init_simple_test("STT6188");
    static STRUCT_IF_C STT6188 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6188)");
    check_field_offset(lv, fa, 0, "STT6188.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6188");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6188");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6188, STT6188)
//============================================================================


struct  STT6198  {
  float fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT6198) C1{ Fi Fs:8 FD}



static void Test_STT6198()
{
  {
    init_simple_test("STT6198");
    static STRUCT_IF_C STT6198 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6198)");
    check_field_offset(lv, fa, 0, "STT6198.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6198");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6198");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6198, STT6198)
//============================================================================


struct  STT6208  {
  float fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT6208) C1{ Fi Fi:8 FD}



static void Test_STT6208()
{
  {
    init_simple_test("STT6208");
    static STRUCT_IF_C STT6208 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6208)");
    check_field_offset(lv, fa, 0, "STT6208.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6208");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6208");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6208, STT6208)
//============================================================================


struct  STT6218  {
  float fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT6218) C1{ Fi FL:8 FD}



static void Test_STT6218()
{
  {
    init_simple_test("STT6218");
    static STRUCT_IF_C STT6218 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6218)");
    check_field_offset(lv, fa, 0, "STT6218.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6218");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6218");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6218, STT6218)
//============================================================================


struct  STT6228  {
  float fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT6228) C1{ Fi Fi:18 FD}



static void Test_STT6228()
{
  {
    init_simple_test("STT6228");
    static STRUCT_IF_C STT6228 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6228)");
    check_field_offset(lv, fa, 0, "STT6228.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6228");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6228");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6228, STT6228)
//============================================================================


struct  STT6238  {
  float fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT6238) C1{ Fi FL:18 FD}



static void Test_STT6238()
{
  {
    init_simple_test("STT6238");
    static STRUCT_IF_C STT6238 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT6238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6238)");
    check_field_offset(lv, fa, 0, "STT6238.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6238");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6238");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT6238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6238, STT6238)
//============================================================================


struct  STT6248  {
  float fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT6248) C1{ Fi FL:48 FD}



static void Test_STT6248()
{
  {
    init_simple_test("STT6248");
    static STRUCT_IF_C STT6248 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT6248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT6248)");
    check_field_offset(lv, fa, 0, "STT6248.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6248");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6248");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT6248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6248, STT6248)
//============================================================================


struct  STT619  {
  float fa;
  unsigned char  :0;
};
//SIG(1 STT619) C1{ Fi Fc:0}



static void Test_STT619()
{
  {
    init_simple_test("STT619");
    static STRUCT_IF_C STT619 lv;
    check2(sizeof(lv), 4, "sizeof(STT619)");
    check2(__alignof__(lv), 4, "__alignof__(STT619)");
    check_field_offset(lv, fa, 0, "STT619.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT619, STT619)
//============================================================================


struct  STT629  {
  float fa;
  unsigned short  :0;
};
//SIG(1 STT629) C1{ Fi Fs:0}



static void Test_STT629()
{
  {
    init_simple_test("STT629");
    static STRUCT_IF_C STT629 lv;
    check2(sizeof(lv), 4, "sizeof(STT629)");
    check2(__alignof__(lv), 4, "__alignof__(STT629)");
    check_field_offset(lv, fa, 0, "STT629.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT629, STT629)
//============================================================================


struct  STT639  {
  float fa;
  unsigned int  :0;
};
//SIG(1 STT639) C1{ Fi Fi:0}



static void Test_STT639()
{
  {
    init_simple_test("STT639");
    static STRUCT_IF_C STT639 lv;
    check2(sizeof(lv), 4, "sizeof(STT639)");
    check2(__alignof__(lv), 4, "__alignof__(STT639)");
    check_field_offset(lv, fa, 0, "STT639.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT639, STT639)
//============================================================================


struct  STT649  {
  float fa;
  __tsu64  :0;
};
//SIG(1 STT649) C1{ Fi FL:0}



static void Test_STT649()
{
  {
    init_simple_test("STT649");
    static STRUCT_IF_C STT649 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT649)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT649)");
    check_field_offset(lv, fa, 0, "STT649.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT649, STT649)
//============================================================================


struct  STT659  {
  float fa;
  unsigned char  :3;
};
//SIG(1 STT659) C1{ Fi Fc:3}



static void Test_STT659()
{
  {
    init_simple_test("STT659");
    static STRUCT_IF_C STT659 lv;
    check2(sizeof(lv), 8, "sizeof(STT659)");
    check2(__alignof__(lv), 4, "__alignof__(STT659)");
    check_field_offset(lv, fa, 0, "STT659.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT659, STT659)
//============================================================================


struct  STT669  {
  float fa;
  unsigned short  :3;
};
//SIG(1 STT669) C1{ Fi Fs:3}



static void Test_STT669()
{
  {
    init_simple_test("STT669");
    static STRUCT_IF_C STT669 lv;
    check2(sizeof(lv), 8, "sizeof(STT669)");
    check2(__alignof__(lv), 4, "__alignof__(STT669)");
    check_field_offset(lv, fa, 0, "STT669.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT669, STT669)
//============================================================================


struct  STT679  {
  float fa;
  unsigned int  :3;
};
//SIG(1 STT679) C1{ Fi Fi:3}



static void Test_STT679()
{
  {
    init_simple_test("STT679");
    static STRUCT_IF_C STT679 lv;
    check2(sizeof(lv), 8, "sizeof(STT679)");
    check2(__alignof__(lv), 4, "__alignof__(STT679)");
    check_field_offset(lv, fa, 0, "STT679.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT679, STT679)
//============================================================================


struct  STT689  {
  float fa;
  __tsu64  :3;
};
//SIG(1 STT689) C1{ Fi FL:3}



static void Test_STT689()
{
  {
    init_simple_test("STT689");
    static STRUCT_IF_C STT689 lv;
    check2(sizeof(lv), 8, "sizeof(STT689)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT689)");
    check_field_offset(lv, fa, 0, "STT689.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT689, STT689)
//============================================================================


struct  STT699  {
  float fa;
  unsigned short  :8;
};
//SIG(1 STT699) C1{ Fi Fs:8}



static void Test_STT699()
{
  {
    init_simple_test("STT699");
    static STRUCT_IF_C STT699 lv;
    check2(sizeof(lv), 8, "sizeof(STT699)");
    check2(__alignof__(lv), 4, "__alignof__(STT699)");
    check_field_offset(lv, fa, 0, "STT699.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT699, STT699)
//============================================================================


struct  STT6109  {
  float fa;
  unsigned int  :8;
};
//SIG(1 STT6109) C1{ Fi Fi:8}



static void Test_STT6109()
{
  {
    init_simple_test("STT6109");
    static STRUCT_IF_C STT6109 lv;
    check2(sizeof(lv), 8, "sizeof(STT6109)");
    check2(__alignof__(lv), 4, "__alignof__(STT6109)");
    check_field_offset(lv, fa, 0, "STT6109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6109, STT6109)
//============================================================================


struct  STT6119  {
  float fa;
  __tsu64  :8;
};
//SIG(1 STT6119) C1{ Fi FL:8}



static void Test_STT6119()
{
  {
    init_simple_test("STT6119");
    static STRUCT_IF_C STT6119 lv;
    check2(sizeof(lv), 8, "sizeof(STT6119)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6119)");
    check_field_offset(lv, fa, 0, "STT6119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6119, STT6119)
//============================================================================


struct  STT6129  {
  float fa;
  unsigned int  :18;
};
//SIG(1 STT6129) C1{ Fi Fi:18}



static void Test_STT6129()
{
  {
    init_simple_test("STT6129");
    static STRUCT_IF_C STT6129 lv;
    check2(sizeof(lv), 8, "sizeof(STT6129)");
    check2(__alignof__(lv), 4, "__alignof__(STT6129)");
    check_field_offset(lv, fa, 0, "STT6129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6129, STT6129)
//============================================================================


struct  STT6139  {
  float fa;
  __tsu64  :18;
};
//SIG(1 STT6139) C1{ Fi FL:18}



static void Test_STT6139()
{
  {
    init_simple_test("STT6139");
    static STRUCT_IF_C STT6139 lv;
    check2(sizeof(lv), 8, "sizeof(STT6139)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6139)");
    check_field_offset(lv, fa, 0, "STT6139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6139, STT6139)
//============================================================================


struct  STT6149  {
  float fa;
  __tsu64  :48;
};
//SIG(1 STT6149) C1{ Fi FL:48}



static void Test_STT6149()
{
  {
    init_simple_test("STT6149");
    static STRUCT_IF_C STT6149 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6149)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT6149)");
    check_field_offset(lv, fa, 0, "STT6149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6149, STT6149)
//============================================================================


struct  STT6159  {
  float fa;
  unsigned char bf:3;
};
//SIG(1 STT6159) C1{ Fi Fc:3}



static void Test_STT6159()
{
  {
    init_simple_test("STT6159");
    static STRUCT_IF_C STT6159 lv;
    check2(sizeof(lv), 8, "sizeof(STT6159)");
    check2(__alignof__(lv), 4, "__alignof__(STT6159)");
    check_field_offset(lv, fa, 0, "STT6159.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6159");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6159, STT6159)
//============================================================================


struct  STT6169  {
  float fa;
  unsigned short bf:3;
};
//SIG(1 STT6169) C1{ Fi Fs:3}



static void Test_STT6169()
{
  {
    init_simple_test("STT6169");
    static STRUCT_IF_C STT6169 lv;
    check2(sizeof(lv), 8, "sizeof(STT6169)");
    check2(__alignof__(lv), 4, "__alignof__(STT6169)");
    check_field_offset(lv, fa, 0, "STT6169.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6169");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6169, STT6169)
//============================================================================


struct  STT6179  {
  float fa;
  unsigned int bf:3;
};
//SIG(1 STT6179) C1{ Fi Fi:3}



static void Test_STT6179()
{
  {
    init_simple_test("STT6179");
    static STRUCT_IF_C STT6179 lv;
    check2(sizeof(lv), 8, "sizeof(STT6179)");
    check2(__alignof__(lv), 4, "__alignof__(STT6179)");
    check_field_offset(lv, fa, 0, "STT6179.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6179");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6179, STT6179)
//============================================================================


struct  STT6189  {
  float fa;
  __tsu64 bf:3;
};
//SIG(1 STT6189) C1{ Fi FL:3}



static void Test_STT6189()
{
  {
    init_simple_test("STT6189");
    static STRUCT_IF_C STT6189 lv;
    check2(sizeof(lv), 8, "sizeof(STT6189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6189)");
    check_field_offset(lv, fa, 0, "STT6189.fa");
    set_bf_and_test(lv, bf, 4, 0, 3, 1, "STT6189");
    set_bf_and_test(lv, bf, 4, 0, 3, hide_ull(1LL<<2), "STT6189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6189, STT6189)
//============================================================================


struct  STT6199  {
  float fa;
  unsigned short bf:8;
};
//SIG(1 STT6199) C1{ Fi Fs:8}



static void Test_STT6199()
{
  {
    init_simple_test("STT6199");
    static STRUCT_IF_C STT6199 lv;
    check2(sizeof(lv), 8, "sizeof(STT6199)");
    check2(__alignof__(lv), 4, "__alignof__(STT6199)");
    check_field_offset(lv, fa, 0, "STT6199.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6199");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6199, STT6199)
//============================================================================


struct  STT6209  {
  float fa;
  unsigned int bf:8;
};
//SIG(1 STT6209) C1{ Fi Fi:8}



static void Test_STT6209()
{
  {
    init_simple_test("STT6209");
    static STRUCT_IF_C STT6209 lv;
    check2(sizeof(lv), 8, "sizeof(STT6209)");
    check2(__alignof__(lv), 4, "__alignof__(STT6209)");
    check_field_offset(lv, fa, 0, "STT6209.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6209");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6209, STT6209)
//============================================================================


struct  STT6219  {
  float fa;
  __tsu64 bf:8;
};
//SIG(1 STT6219) C1{ Fi FL:8}



static void Test_STT6219()
{
  {
    init_simple_test("STT6219");
    static STRUCT_IF_C STT6219 lv;
    check2(sizeof(lv), 8, "sizeof(STT6219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6219)");
    check_field_offset(lv, fa, 0, "STT6219.fa");
    set_bf_and_test(lv, bf, 4, 0, 8, 1, "STT6219");
    set_bf_and_test(lv, bf, 4, 0, 8, hide_ull(1LL<<7), "STT6219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6219, STT6219)
//============================================================================


struct  STT6229  {
  float fa;
  unsigned int bf:18;
};
//SIG(1 STT6229) C1{ Fi Fi:18}



static void Test_STT6229()
{
  {
    init_simple_test("STT6229");
    static STRUCT_IF_C STT6229 lv;
    check2(sizeof(lv), 8, "sizeof(STT6229)");
    check2(__alignof__(lv), 4, "__alignof__(STT6229)");
    check_field_offset(lv, fa, 0, "STT6229.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6229");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6229, STT6229)
//============================================================================


struct  STT6239  {
  float fa;
  __tsu64 bf:18;
};
//SIG(1 STT6239) C1{ Fi FL:18}



static void Test_STT6239()
{
  {
    init_simple_test("STT6239");
    static STRUCT_IF_C STT6239 lv;
    check2(sizeof(lv), 8, "sizeof(STT6239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6239)");
    check_field_offset(lv, fa, 0, "STT6239.fa");
    set_bf_and_test(lv, bf, 4, 0, 18, 1, "STT6239");
    set_bf_and_test(lv, bf, 4, 0, 18, hide_ull(1LL<<17), "STT6239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6239, STT6239)
//============================================================================


struct  STT6249  {
  float fa;
  __tsu64 bf:48;
};
//SIG(1 STT6249) C1{ Fi FL:48}



static void Test_STT6249()
{
  {
    init_simple_test("STT6249");
    static STRUCT_IF_C STT6249 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT6249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT6249)");
    check_field_offset(lv, fa, 0, "STT6249.fa");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, 1, "STT6249");
    set_bf_and_test(lv, bf, ABISELECT(8,4), 0, 48, hide_ull(1LL<<47), "STT6249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT6249, STT6249)
//============================================================================


struct  STT710  {
  double fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT710) C1{ FL Fc:0 Fc}



static void Test_STT710()
{
  {
    init_simple_test("STT710");
    static STRUCT_IF_C STT710 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT710)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT710)");
    check_field_offset(lv, fa, 0, "STT710.fa");
    check_field_offset(lv, fb, 8, "STT710.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT710, STT710)
//============================================================================


struct  STT720  {
  double fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT720) C1{ FL Fs:0 Fc}



static void Test_STT720()
{
  {
    init_simple_test("STT720");
    static STRUCT_IF_C STT720 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT720)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT720)");
    check_field_offset(lv, fa, 0, "STT720.fa");
    check_field_offset(lv, fb, 8, "STT720.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT720, STT720)
//============================================================================


struct  STT730  {
  double fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT730) C1{ FL Fi:0 Fc}



static void Test_STT730()
{
  {
    init_simple_test("STT730");
    static STRUCT_IF_C STT730 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT730)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT730)");
    check_field_offset(lv, fa, 0, "STT730.fa");
    check_field_offset(lv, fb, 8, "STT730.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT730, STT730)
//============================================================================


struct  STT740  {
  double fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT740) C1{ FL FL:0 Fc}



static void Test_STT740()
{
  {
    init_simple_test("STT740");
    static STRUCT_IF_C STT740 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT740)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT740)");
    check_field_offset(lv, fa, 0, "STT740.fa");
    check_field_offset(lv, fb, 8, "STT740.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT740, STT740)
//============================================================================


struct  STT750  {
  double fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT750) C1{ FL Fc:3 Fc}



static void Test_STT750()
{
  {
    init_simple_test("STT750");
    static STRUCT_IF_C STT750 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT750)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT750)");
    check_field_offset(lv, fa, 0, "STT750.fa");
    check_field_offset(lv, fb, 9, "STT750.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT750, STT750)
//============================================================================


struct  STT760  {
  double fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT760) C1{ FL Fs:3 Fc}



static void Test_STT760()
{
  {
    init_simple_test("STT760");
    static STRUCT_IF_C STT760 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT760)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT760)");
    check_field_offset(lv, fa, 0, "STT760.fa");
    check_field_offset(lv, fb, 9, "STT760.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT760, STT760)
//============================================================================


struct  STT770  {
  double fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT770) C1{ FL Fi:3 Fc}



static void Test_STT770()
{
  {
    init_simple_test("STT770");
    static STRUCT_IF_C STT770 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT770)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT770)");
    check_field_offset(lv, fa, 0, "STT770.fa");
    check_field_offset(lv, fb, 9, "STT770.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT770, STT770)
//============================================================================


struct  STT780  {
  double fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT780) C1{ FL FL:3 Fc}



static void Test_STT780()
{
  {
    init_simple_test("STT780");
    static STRUCT_IF_C STT780 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT780)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT780)");
    check_field_offset(lv, fa, 0, "STT780.fa");
    check_field_offset(lv, fb, 9, "STT780.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT780, STT780)
//============================================================================


struct  STT790  {
  double fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT790) C1{ FL Fs:8 Fc}



static void Test_STT790()
{
  {
    init_simple_test("STT790");
    static STRUCT_IF_C STT790 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT790)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT790)");
    check_field_offset(lv, fa, 0, "STT790.fa");
    check_field_offset(lv, fb, 9, "STT790.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT790, STT790)
//============================================================================


struct  STT7100  {
  double fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT7100) C1{ FL Fi:8 Fc}



static void Test_STT7100()
{
  {
    init_simple_test("STT7100");
    static STRUCT_IF_C STT7100 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7100)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7100)");
    check_field_offset(lv, fa, 0, "STT7100.fa");
    check_field_offset(lv, fb, 9, "STT7100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7100, STT7100)
//============================================================================


struct  STT7110  {
  double fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT7110) C1{ FL FL:8 Fc}



static void Test_STT7110()
{
  {
    init_simple_test("STT7110");
    static STRUCT_IF_C STT7110 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7110)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7110)");
    check_field_offset(lv, fa, 0, "STT7110.fa");
    check_field_offset(lv, fb, 9, "STT7110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7110, STT7110)
//============================================================================


struct  STT7120  {
  double fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT7120) C1{ FL Fi:18 Fc}



static void Test_STT7120()
{
  {
    init_simple_test("STT7120");
    static STRUCT_IF_C STT7120 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7120)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7120)");
    check_field_offset(lv, fa, 0, "STT7120.fa");
    check_field_offset(lv, fb, 11, "STT7120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7120, STT7120)
//============================================================================


struct  STT7130  {
  double fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT7130) C1{ FL FL:18 Fc}



static void Test_STT7130()
{
  {
    init_simple_test("STT7130");
    static STRUCT_IF_C STT7130 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7130)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7130)");
    check_field_offset(lv, fa, 0, "STT7130.fa");
    check_field_offset(lv, fb, 11, "STT7130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7130, STT7130)
//============================================================================


struct  STT7140  {
  double fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT7140) C1{ FL FL:48 Fc}



static void Test_STT7140()
{
  {
    init_simple_test("STT7140");
    static STRUCT_IF_C STT7140 lv;
    check2(sizeof(lv), 16, "sizeof(STT7140)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7140)");
    check_field_offset(lv, fa, 0, "STT7140.fa");
    check_field_offset(lv, fb, 14, "STT7140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7140, STT7140)
//============================================================================


struct  STT7150  {
  double fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT7150) C1{ FL Fc:3 Fc}



static void Test_STT7150()
{
  {
    init_simple_test("STT7150");
    static STRUCT_IF_C STT7150 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7150)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7150)");
    check_field_offset(lv, fa, 0, "STT7150.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7150");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7150");
    check_field_offset(lv, fb, 9, "STT7150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7150, STT7150)
//============================================================================


struct  STT7160  {
  double fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT7160) C1{ FL Fs:3 Fc}



static void Test_STT7160()
{
  {
    init_simple_test("STT7160");
    static STRUCT_IF_C STT7160 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7160)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7160)");
    check_field_offset(lv, fa, 0, "STT7160.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7160");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7160");
    check_field_offset(lv, fb, 9, "STT7160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7160, STT7160)
//============================================================================


struct  STT7170  {
  double fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT7170) C1{ FL Fi:3 Fc}



static void Test_STT7170()
{
  {
    init_simple_test("STT7170");
    static STRUCT_IF_C STT7170 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7170)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7170)");
    check_field_offset(lv, fa, 0, "STT7170.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7170");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7170");
    check_field_offset(lv, fb, 9, "STT7170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7170, STT7170)
//============================================================================


struct  STT7180  {
  double fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT7180) C1{ FL FL:3 Fc}



static void Test_STT7180()
{
  {
    init_simple_test("STT7180");
    static STRUCT_IF_C STT7180 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7180)");
    check_field_offset(lv, fa, 0, "STT7180.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7180");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7180");
    check_field_offset(lv, fb, 9, "STT7180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7180, STT7180)
//============================================================================


struct  STT7190  {
  double fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT7190) C1{ FL Fs:8 Fc}



static void Test_STT7190()
{
  {
    init_simple_test("STT7190");
    static STRUCT_IF_C STT7190 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7190)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7190)");
    check_field_offset(lv, fa, 0, "STT7190.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7190");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7190");
    check_field_offset(lv, fb, 9, "STT7190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7190, STT7190)
//============================================================================


struct  STT7200  {
  double fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT7200) C1{ FL Fi:8 Fc}



static void Test_STT7200()
{
  {
    init_simple_test("STT7200");
    static STRUCT_IF_C STT7200 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7200)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7200)");
    check_field_offset(lv, fa, 0, "STT7200.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7200");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7200");
    check_field_offset(lv, fb, 9, "STT7200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7200, STT7200)
//============================================================================


struct  STT7210  {
  double fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT7210) C1{ FL FL:8 Fc}



static void Test_STT7210()
{
  {
    init_simple_test("STT7210");
    static STRUCT_IF_C STT7210 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7210)");
    check_field_offset(lv, fa, 0, "STT7210.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7210");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7210");
    check_field_offset(lv, fb, 9, "STT7210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7210, STT7210)
//============================================================================


struct  STT7220  {
  double fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT7220) C1{ FL Fi:18 Fc}



static void Test_STT7220()
{
  {
    init_simple_test("STT7220");
    static STRUCT_IF_C STT7220 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7220)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7220)");
    check_field_offset(lv, fa, 0, "STT7220.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7220");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7220");
    check_field_offset(lv, fb, 11, "STT7220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7220, STT7220)
//============================================================================


struct  STT7230  {
  double fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT7230) C1{ FL FL:18 Fc}



static void Test_STT7230()
{
  {
    init_simple_test("STT7230");
    static STRUCT_IF_C STT7230 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7230)");
    check_field_offset(lv, fa, 0, "STT7230.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7230");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7230");
    check_field_offset(lv, fb, 11, "STT7230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7230, STT7230)
//============================================================================


struct  STT7240  {
  double fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT7240) C1{ FL FL:48 Fc}



static void Test_STT7240()
{
  {
    init_simple_test("STT7240");
    static STRUCT_IF_C STT7240 lv;
    check2(sizeof(lv), 16, "sizeof(STT7240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7240)");
    check_field_offset(lv, fa, 0, "STT7240.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7240");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7240");
    check_field_offset(lv, fb, 14, "STT7240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7240, STT7240)
//============================================================================


struct  STT711  {
  double fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT711) C1{ FL Fc:0 Fs}



static void Test_STT711()
{
  {
    init_simple_test("STT711");
    static STRUCT_IF_C STT711 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT711)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT711)");
    check_field_offset(lv, fa, 0, "STT711.fa");
    check_field_offset(lv, fb, 8, "STT711.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT711, STT711)
//============================================================================


struct  STT721  {
  double fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT721) C1{ FL Fs:0 Fs}



static void Test_STT721()
{
  {
    init_simple_test("STT721");
    static STRUCT_IF_C STT721 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT721)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT721)");
    check_field_offset(lv, fa, 0, "STT721.fa");
    check_field_offset(lv, fb, 8, "STT721.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT721, STT721)
//============================================================================


struct  STT731  {
  double fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT731) C1{ FL Fi:0 Fs}



static void Test_STT731()
{
  {
    init_simple_test("STT731");
    static STRUCT_IF_C STT731 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT731)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT731)");
    check_field_offset(lv, fa, 0, "STT731.fa");
    check_field_offset(lv, fb, 8, "STT731.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT731, STT731)
//============================================================================


struct  STT741  {
  double fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT741) C1{ FL FL:0 Fs}



static void Test_STT741()
{
  {
    init_simple_test("STT741");
    static STRUCT_IF_C STT741 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT741)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT741)");
    check_field_offset(lv, fa, 0, "STT741.fa");
    check_field_offset(lv, fb, 8, "STT741.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT741, STT741)
//============================================================================


struct  STT751  {
  double fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT751) C1{ FL Fc:3 Fs}



static void Test_STT751()
{
  {
    init_simple_test("STT751");
    static STRUCT_IF_C STT751 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT751)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT751)");
    check_field_offset(lv, fa, 0, "STT751.fa");
    check_field_offset(lv, fb, 10, "STT751.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT751, STT751)
//============================================================================


struct  STT761  {
  double fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT761) C1{ FL Fs:3 Fs}



static void Test_STT761()
{
  {
    init_simple_test("STT761");
    static STRUCT_IF_C STT761 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT761)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT761)");
    check_field_offset(lv, fa, 0, "STT761.fa");
    check_field_offset(lv, fb, 10, "STT761.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT761, STT761)
//============================================================================


struct  STT771  {
  double fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT771) C1{ FL Fi:3 Fs}



static void Test_STT771()
{
  {
    init_simple_test("STT771");
    static STRUCT_IF_C STT771 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT771)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT771)");
    check_field_offset(lv, fa, 0, "STT771.fa");
    check_field_offset(lv, fb, 10, "STT771.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT771, STT771)
//============================================================================


struct  STT781  {
  double fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT781) C1{ FL FL:3 Fs}



static void Test_STT781()
{
  {
    init_simple_test("STT781");
    static STRUCT_IF_C STT781 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT781)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT781)");
    check_field_offset(lv, fa, 0, "STT781.fa");
    check_field_offset(lv, fb, 10, "STT781.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT781, STT781)
//============================================================================


struct  STT791  {
  double fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT791) C1{ FL Fs:8 Fs}



static void Test_STT791()
{
  {
    init_simple_test("STT791");
    static STRUCT_IF_C STT791 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT791)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT791)");
    check_field_offset(lv, fa, 0, "STT791.fa");
    check_field_offset(lv, fb, 10, "STT791.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT791, STT791)
//============================================================================


struct  STT7101  {
  double fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT7101) C1{ FL Fi:8 Fs}



static void Test_STT7101()
{
  {
    init_simple_test("STT7101");
    static STRUCT_IF_C STT7101 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7101)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7101)");
    check_field_offset(lv, fa, 0, "STT7101.fa");
    check_field_offset(lv, fb, 10, "STT7101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7101, STT7101)
//============================================================================


struct  STT7111  {
  double fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT7111) C1{ FL FL:8 Fs}



static void Test_STT7111()
{
  {
    init_simple_test("STT7111");
    static STRUCT_IF_C STT7111 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7111)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7111)");
    check_field_offset(lv, fa, 0, "STT7111.fa");
    check_field_offset(lv, fb, 10, "STT7111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7111, STT7111)
//============================================================================


struct  STT7121  {
  double fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT7121) C1{ FL Fi:18 Fs}



static void Test_STT7121()
{
  {
    init_simple_test("STT7121");
    static STRUCT_IF_C STT7121 lv;
    check2(sizeof(lv), 16, "sizeof(STT7121)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7121)");
    check_field_offset(lv, fa, 0, "STT7121.fa");
    check_field_offset(lv, fb, 12, "STT7121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7121, STT7121)
//============================================================================


struct  STT7131  {
  double fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT7131) C1{ FL FL:18 Fs}



static void Test_STT7131()
{
  {
    init_simple_test("STT7131");
    static STRUCT_IF_C STT7131 lv;
    check2(sizeof(lv), 16, "sizeof(STT7131)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7131)");
    check_field_offset(lv, fa, 0, "STT7131.fa");
    check_field_offset(lv, fb, 12, "STT7131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7131, STT7131)
//============================================================================


struct  STT7141  {
  double fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT7141) C1{ FL FL:48 Fs}



static void Test_STT7141()
{
  {
    init_simple_test("STT7141");
    static STRUCT_IF_C STT7141 lv;
    check2(sizeof(lv), 16, "sizeof(STT7141)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7141)");
    check_field_offset(lv, fa, 0, "STT7141.fa");
    check_field_offset(lv, fb, 14, "STT7141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7141, STT7141)
//============================================================================


struct  STT7151  {
  double fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT7151) C1{ FL Fc:3 Fs}



static void Test_STT7151()
{
  {
    init_simple_test("STT7151");
    static STRUCT_IF_C STT7151 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7151)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7151)");
    check_field_offset(lv, fa, 0, "STT7151.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7151");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7151");
    check_field_offset(lv, fb, 10, "STT7151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7151, STT7151)
//============================================================================


struct  STT7161  {
  double fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT7161) C1{ FL Fs:3 Fs}



static void Test_STT7161()
{
  {
    init_simple_test("STT7161");
    static STRUCT_IF_C STT7161 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7161)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7161)");
    check_field_offset(lv, fa, 0, "STT7161.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7161");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7161");
    check_field_offset(lv, fb, 10, "STT7161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7161, STT7161)
//============================================================================


struct  STT7171  {
  double fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT7171) C1{ FL Fi:3 Fs}



static void Test_STT7171()
{
  {
    init_simple_test("STT7171");
    static STRUCT_IF_C STT7171 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7171)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7171)");
    check_field_offset(lv, fa, 0, "STT7171.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7171");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7171");
    check_field_offset(lv, fb, 10, "STT7171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7171, STT7171)
//============================================================================


struct  STT7181  {
  double fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT7181) C1{ FL FL:3 Fs}



static void Test_STT7181()
{
  {
    init_simple_test("STT7181");
    static STRUCT_IF_C STT7181 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7181)");
    check_field_offset(lv, fa, 0, "STT7181.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7181");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7181");
    check_field_offset(lv, fb, 10, "STT7181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7181, STT7181)
//============================================================================


struct  STT7191  {
  double fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT7191) C1{ FL Fs:8 Fs}



static void Test_STT7191()
{
  {
    init_simple_test("STT7191");
    static STRUCT_IF_C STT7191 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7191)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7191)");
    check_field_offset(lv, fa, 0, "STT7191.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7191");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7191");
    check_field_offset(lv, fb, 10, "STT7191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7191, STT7191)
//============================================================================


struct  STT7201  {
  double fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT7201) C1{ FL Fi:8 Fs}



static void Test_STT7201()
{
  {
    init_simple_test("STT7201");
    static STRUCT_IF_C STT7201 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7201)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7201)");
    check_field_offset(lv, fa, 0, "STT7201.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7201");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7201");
    check_field_offset(lv, fb, 10, "STT7201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7201, STT7201)
//============================================================================


struct  STT7211  {
  double fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT7211) C1{ FL FL:8 Fs}



static void Test_STT7211()
{
  {
    init_simple_test("STT7211");
    static STRUCT_IF_C STT7211 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7211)");
    check_field_offset(lv, fa, 0, "STT7211.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7211");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7211");
    check_field_offset(lv, fb, 10, "STT7211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7211, STT7211)
//============================================================================


struct  STT7221  {
  double fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT7221) C1{ FL Fi:18 Fs}



static void Test_STT7221()
{
  {
    init_simple_test("STT7221");
    static STRUCT_IF_C STT7221 lv;
    check2(sizeof(lv), 16, "sizeof(STT7221)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7221)");
    check_field_offset(lv, fa, 0, "STT7221.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7221");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7221");
    check_field_offset(lv, fb, 12, "STT7221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7221, STT7221)
//============================================================================


struct  STT7231  {
  double fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT7231) C1{ FL FL:18 Fs}



static void Test_STT7231()
{
  {
    init_simple_test("STT7231");
    static STRUCT_IF_C STT7231 lv;
    check2(sizeof(lv), 16, "sizeof(STT7231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7231)");
    check_field_offset(lv, fa, 0, "STT7231.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7231");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7231");
    check_field_offset(lv, fb, 12, "STT7231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7231, STT7231)
//============================================================================


struct  STT7241  {
  double fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT7241) C1{ FL FL:48 Fs}



static void Test_STT7241()
{
  {
    init_simple_test("STT7241");
    static STRUCT_IF_C STT7241 lv;
    check2(sizeof(lv), 16, "sizeof(STT7241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7241)");
    check_field_offset(lv, fa, 0, "STT7241.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7241");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7241");
    check_field_offset(lv, fb, 14, "STT7241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7241, STT7241)
//============================================================================


struct  STT712  {
  double fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT712) C1{ FL Fc:0 Fi}



static void Test_STT712()
{
  {
    init_simple_test("STT712");
    static STRUCT_IF_C STT712 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT712)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT712)");
    check_field_offset(lv, fa, 0, "STT712.fa");
    check_field_offset(lv, fb, 8, "STT712.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT712, STT712)
//============================================================================


struct  STT722  {
  double fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT722) C1{ FL Fs:0 Fi}



static void Test_STT722()
{
  {
    init_simple_test("STT722");
    static STRUCT_IF_C STT722 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT722)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT722)");
    check_field_offset(lv, fa, 0, "STT722.fa");
    check_field_offset(lv, fb, 8, "STT722.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT722, STT722)
//============================================================================


struct  STT732  {
  double fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT732) C1{ FL Fi:0 Fi}



static void Test_STT732()
{
  {
    init_simple_test("STT732");
    static STRUCT_IF_C STT732 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT732)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT732)");
    check_field_offset(lv, fa, 0, "STT732.fa");
    check_field_offset(lv, fb, 8, "STT732.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT732, STT732)
//============================================================================


struct  STT742  {
  double fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT742) C1{ FL FL:0 Fi}



static void Test_STT742()
{
  {
    init_simple_test("STT742");
    static STRUCT_IF_C STT742 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT742)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT742)");
    check_field_offset(lv, fa, 0, "STT742.fa");
    check_field_offset(lv, fb, 8, "STT742.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT742, STT742)
//============================================================================


struct  STT752  {
  double fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT752) C1{ FL Fc:3 Fi}



static void Test_STT752()
{
  {
    init_simple_test("STT752");
    static STRUCT_IF_C STT752 lv;
    check2(sizeof(lv), 16, "sizeof(STT752)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT752)");
    check_field_offset(lv, fa, 0, "STT752.fa");
    check_field_offset(lv, fb, 12, "STT752.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT752, STT752)
//============================================================================


struct  STT762  {
  double fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT762) C1{ FL Fs:3 Fi}



static void Test_STT762()
{
  {
    init_simple_test("STT762");
    static STRUCT_IF_C STT762 lv;
    check2(sizeof(lv), 16, "sizeof(STT762)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT762)");
    check_field_offset(lv, fa, 0, "STT762.fa");
    check_field_offset(lv, fb, 12, "STT762.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT762, STT762)
//============================================================================


struct  STT772  {
  double fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT772) C1{ FL Fi:3 Fi}



static void Test_STT772()
{
  {
    init_simple_test("STT772");
    static STRUCT_IF_C STT772 lv;
    check2(sizeof(lv), 16, "sizeof(STT772)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT772)");
    check_field_offset(lv, fa, 0, "STT772.fa");
    check_field_offset(lv, fb, 12, "STT772.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT772, STT772)
//============================================================================


struct  STT782  {
  double fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT782) C1{ FL FL:3 Fi}



static void Test_STT782()
{
  {
    init_simple_test("STT782");
    static STRUCT_IF_C STT782 lv;
    check2(sizeof(lv), 16, "sizeof(STT782)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT782)");
    check_field_offset(lv, fa, 0, "STT782.fa");
    check_field_offset(lv, fb, 12, "STT782.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT782, STT782)
//============================================================================


struct  STT792  {
  double fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT792) C1{ FL Fs:8 Fi}



static void Test_STT792()
{
  {
    init_simple_test("STT792");
    static STRUCT_IF_C STT792 lv;
    check2(sizeof(lv), 16, "sizeof(STT792)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT792)");
    check_field_offset(lv, fa, 0, "STT792.fa");
    check_field_offset(lv, fb, 12, "STT792.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT792, STT792)
//============================================================================


struct  STT7102  {
  double fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT7102) C1{ FL Fi:8 Fi}



static void Test_STT7102()
{
  {
    init_simple_test("STT7102");
    static STRUCT_IF_C STT7102 lv;
    check2(sizeof(lv), 16, "sizeof(STT7102)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7102)");
    check_field_offset(lv, fa, 0, "STT7102.fa");
    check_field_offset(lv, fb, 12, "STT7102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7102, STT7102)
//============================================================================


struct  STT7112  {
  double fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT7112) C1{ FL FL:8 Fi}



static void Test_STT7112()
{
  {
    init_simple_test("STT7112");
    static STRUCT_IF_C STT7112 lv;
    check2(sizeof(lv), 16, "sizeof(STT7112)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7112)");
    check_field_offset(lv, fa, 0, "STT7112.fa");
    check_field_offset(lv, fb, 12, "STT7112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7112, STT7112)
//============================================================================


struct  STT7122  {
  double fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT7122) C1{ FL Fi:18 Fi}



static void Test_STT7122()
{
  {
    init_simple_test("STT7122");
    static STRUCT_IF_C STT7122 lv;
    check2(sizeof(lv), 16, "sizeof(STT7122)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7122)");
    check_field_offset(lv, fa, 0, "STT7122.fa");
    check_field_offset(lv, fb, 12, "STT7122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7122, STT7122)
//============================================================================


struct  STT7132  {
  double fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT7132) C1{ FL FL:18 Fi}



static void Test_STT7132()
{
  {
    init_simple_test("STT7132");
    static STRUCT_IF_C STT7132 lv;
    check2(sizeof(lv), 16, "sizeof(STT7132)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7132)");
    check_field_offset(lv, fa, 0, "STT7132.fa");
    check_field_offset(lv, fb, 12, "STT7132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7132, STT7132)
//============================================================================


struct  STT7142  {
  double fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT7142) C1{ FL FL:48 Fi}



static void Test_STT7142()
{
  {
    init_simple_test("STT7142");
    static STRUCT_IF_C STT7142 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7142)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7142)");
    check_field_offset(lv, fa, 0, "STT7142.fa");
    check_field_offset(lv, fb, 16, "STT7142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7142, STT7142)
//============================================================================


struct  STT7152  {
  double fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT7152) C1{ FL Fc:3 Fi}



static void Test_STT7152()
{
  {
    init_simple_test("STT7152");
    static STRUCT_IF_C STT7152 lv;
    check2(sizeof(lv), 16, "sizeof(STT7152)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7152)");
    check_field_offset(lv, fa, 0, "STT7152.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7152");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7152");
    check_field_offset(lv, fb, 12, "STT7152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7152, STT7152)
//============================================================================


struct  STT7162  {
  double fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT7162) C1{ FL Fs:3 Fi}



static void Test_STT7162()
{
  {
    init_simple_test("STT7162");
    static STRUCT_IF_C STT7162 lv;
    check2(sizeof(lv), 16, "sizeof(STT7162)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7162)");
    check_field_offset(lv, fa, 0, "STT7162.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7162");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7162");
    check_field_offset(lv, fb, 12, "STT7162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7162, STT7162)
//============================================================================


struct  STT7172  {
  double fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT7172) C1{ FL Fi:3 Fi}



static void Test_STT7172()
{
  {
    init_simple_test("STT7172");
    static STRUCT_IF_C STT7172 lv;
    check2(sizeof(lv), 16, "sizeof(STT7172)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7172)");
    check_field_offset(lv, fa, 0, "STT7172.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7172");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7172");
    check_field_offset(lv, fb, 12, "STT7172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7172, STT7172)
//============================================================================


struct  STT7182  {
  double fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT7182) C1{ FL FL:3 Fi}



static void Test_STT7182()
{
  {
    init_simple_test("STT7182");
    static STRUCT_IF_C STT7182 lv;
    check2(sizeof(lv), 16, "sizeof(STT7182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7182)");
    check_field_offset(lv, fa, 0, "STT7182.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7182");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7182");
    check_field_offset(lv, fb, 12, "STT7182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7182, STT7182)
//============================================================================


struct  STT7192  {
  double fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT7192) C1{ FL Fs:8 Fi}



static void Test_STT7192()
{
  {
    init_simple_test("STT7192");
    static STRUCT_IF_C STT7192 lv;
    check2(sizeof(lv), 16, "sizeof(STT7192)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7192)");
    check_field_offset(lv, fa, 0, "STT7192.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7192");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7192");
    check_field_offset(lv, fb, 12, "STT7192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7192, STT7192)
//============================================================================


struct  STT7202  {
  double fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT7202) C1{ FL Fi:8 Fi}



static void Test_STT7202()
{
  {
    init_simple_test("STT7202");
    static STRUCT_IF_C STT7202 lv;
    check2(sizeof(lv), 16, "sizeof(STT7202)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7202)");
    check_field_offset(lv, fa, 0, "STT7202.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7202");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7202");
    check_field_offset(lv, fb, 12, "STT7202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7202, STT7202)
//============================================================================


struct  STT7212  {
  double fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT7212) C1{ FL FL:8 Fi}



static void Test_STT7212()
{
  {
    init_simple_test("STT7212");
    static STRUCT_IF_C STT7212 lv;
    check2(sizeof(lv), 16, "sizeof(STT7212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7212)");
    check_field_offset(lv, fa, 0, "STT7212.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7212");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7212");
    check_field_offset(lv, fb, 12, "STT7212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7212, STT7212)
//============================================================================


struct  STT7222  {
  double fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT7222) C1{ FL Fi:18 Fi}



static void Test_STT7222()
{
  {
    init_simple_test("STT7222");
    static STRUCT_IF_C STT7222 lv;
    check2(sizeof(lv), 16, "sizeof(STT7222)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7222)");
    check_field_offset(lv, fa, 0, "STT7222.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7222");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7222");
    check_field_offset(lv, fb, 12, "STT7222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7222, STT7222)
//============================================================================


struct  STT7232  {
  double fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT7232) C1{ FL FL:18 Fi}



static void Test_STT7232()
{
  {
    init_simple_test("STT7232");
    static STRUCT_IF_C STT7232 lv;
    check2(sizeof(lv), 16, "sizeof(STT7232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7232)");
    check_field_offset(lv, fa, 0, "STT7232.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7232");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7232");
    check_field_offset(lv, fb, 12, "STT7232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7232, STT7232)
//============================================================================


struct  STT7242  {
  double fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT7242) C1{ FL FL:48 Fi}



static void Test_STT7242()
{
  {
    init_simple_test("STT7242");
    static STRUCT_IF_C STT7242 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7242)");
    check_field_offset(lv, fa, 0, "STT7242.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7242");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7242");
    check_field_offset(lv, fb, 16, "STT7242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7242, STT7242)
//============================================================================


struct  STT713  {
  double fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT713) C1{ FL Fc:0 Fl}



static void Test_STT713()
{
  {
    init_simple_test("STT713");
    static STRUCT_IF_C STT713 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT713)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT713)");
    check_field_offset(lv, fa, 0, "STT713.fa");
    check_field_offset(lv, fb, 8, "STT713.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT713, STT713)
//============================================================================


struct  STT723  {
  double fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT723) C1{ FL Fs:0 Fl}



static void Test_STT723()
{
  {
    init_simple_test("STT723");
    static STRUCT_IF_C STT723 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT723)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT723)");
    check_field_offset(lv, fa, 0, "STT723.fa");
    check_field_offset(lv, fb, 8, "STT723.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT723, STT723)
//============================================================================


struct  STT733  {
  double fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT733) C1{ FL Fi:0 Fl}



static void Test_STT733()
{
  {
    init_simple_test("STT733");
    static STRUCT_IF_C STT733 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT733)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT733)");
    check_field_offset(lv, fa, 0, "STT733.fa");
    check_field_offset(lv, fb, 8, "STT733.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT733, STT733)
//============================================================================


struct  STT743  {
  double fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT743) C1{ FL FL:0 Fl}



static void Test_STT743()
{
  {
    init_simple_test("STT743");
    static STRUCT_IF_C STT743 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT743)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT743)");
    check_field_offset(lv, fa, 0, "STT743.fa");
    check_field_offset(lv, fb, 8, "STT743.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT743, STT743)
//============================================================================


struct  STT753  {
  double fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT753) C1{ FL Fc:3 Fl}



static void Test_STT753()
{
  {
    init_simple_test("STT753");
    static STRUCT_IF_C STT753 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT753)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT753)");
    check_field_offset(lv, fa, 0, "STT753.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT753.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT753, STT753)
//============================================================================


struct  STT763  {
  double fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT763) C1{ FL Fs:3 Fl}



static void Test_STT763()
{
  {
    init_simple_test("STT763");
    static STRUCT_IF_C STT763 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT763)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT763)");
    check_field_offset(lv, fa, 0, "STT763.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT763.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT763, STT763)
//============================================================================


struct  STT773  {
  double fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT773) C1{ FL Fi:3 Fl}



static void Test_STT773()
{
  {
    init_simple_test("STT773");
    static STRUCT_IF_C STT773 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT773)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT773)");
    check_field_offset(lv, fa, 0, "STT773.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT773.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT773, STT773)
//============================================================================


struct  STT783  {
  double fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT783) C1{ FL FL:3 Fl}



static void Test_STT783()
{
  {
    init_simple_test("STT783");
    static STRUCT_IF_C STT783 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT783)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT783)");
    check_field_offset(lv, fa, 0, "STT783.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT783.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT783, STT783)
//============================================================================


struct  STT793  {
  double fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT793) C1{ FL Fs:8 Fl}



static void Test_STT793()
{
  {
    init_simple_test("STT793");
    static STRUCT_IF_C STT793 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT793)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT793)");
    check_field_offset(lv, fa, 0, "STT793.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT793.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT793, STT793)
//============================================================================


struct  STT7103  {
  double fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT7103) C1{ FL Fi:8 Fl}



static void Test_STT7103()
{
  {
    init_simple_test("STT7103");
    static STRUCT_IF_C STT7103 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7103)");
    check_field_offset(lv, fa, 0, "STT7103.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7103, STT7103)
//============================================================================


struct  STT7113  {
  double fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT7113) C1{ FL FL:8 Fl}



static void Test_STT7113()
{
  {
    init_simple_test("STT7113");
    static STRUCT_IF_C STT7113 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7113)");
    check_field_offset(lv, fa, 0, "STT7113.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7113, STT7113)
//============================================================================


struct  STT7123  {
  double fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT7123) C1{ FL Fi:18 Fl}



static void Test_STT7123()
{
  {
    init_simple_test("STT7123");
    static STRUCT_IF_C STT7123 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7123)");
    check_field_offset(lv, fa, 0, "STT7123.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7123, STT7123)
//============================================================================


struct  STT7133  {
  double fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT7133) C1{ FL FL:18 Fl}



static void Test_STT7133()
{
  {
    init_simple_test("STT7133");
    static STRUCT_IF_C STT7133 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7133)");
    check_field_offset(lv, fa, 0, "STT7133.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7133, STT7133)
//============================================================================


struct  STT7143  {
  double fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT7143) C1{ FL FL:48 Fl}



static void Test_STT7143()
{
  {
    init_simple_test("STT7143");
    static STRUCT_IF_C STT7143 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7143)");
    check_field_offset(lv, fa, 0, "STT7143.fa");
    check_field_offset(lv, fb, 16, "STT7143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7143, STT7143)
//============================================================================


struct  STT7153  {
  double fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT7153) C1{ FL Fc:3 Fl}



static void Test_STT7153()
{
  {
    init_simple_test("STT7153");
    static STRUCT_IF_C STT7153 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7153)");
    check_field_offset(lv, fa, 0, "STT7153.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7153");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7153");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7153, STT7153)
//============================================================================


struct  STT7163  {
  double fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT7163) C1{ FL Fs:3 Fl}



static void Test_STT7163()
{
  {
    init_simple_test("STT7163");
    static STRUCT_IF_C STT7163 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7163)");
    check_field_offset(lv, fa, 0, "STT7163.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7163");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7163");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7163, STT7163)
//============================================================================


struct  STT7173  {
  double fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT7173) C1{ FL Fi:3 Fl}



static void Test_STT7173()
{
  {
    init_simple_test("STT7173");
    static STRUCT_IF_C STT7173 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7173)");
    check_field_offset(lv, fa, 0, "STT7173.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7173");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7173");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7173, STT7173)
//============================================================================


struct  STT7183  {
  double fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT7183) C1{ FL FL:3 Fl}



static void Test_STT7183()
{
  {
    init_simple_test("STT7183");
    static STRUCT_IF_C STT7183 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7183)");
    check_field_offset(lv, fa, 0, "STT7183.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7183");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7183");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7183, STT7183)
//============================================================================


struct  STT7193  {
  double fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT7193) C1{ FL Fs:8 Fl}



static void Test_STT7193()
{
  {
    init_simple_test("STT7193");
    static STRUCT_IF_C STT7193 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7193)");
    check_field_offset(lv, fa, 0, "STT7193.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7193");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7193");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7193, STT7193)
//============================================================================


struct  STT7203  {
  double fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT7203) C1{ FL Fi:8 Fl}



static void Test_STT7203()
{
  {
    init_simple_test("STT7203");
    static STRUCT_IF_C STT7203 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7203)");
    check_field_offset(lv, fa, 0, "STT7203.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7203");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7203");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7203, STT7203)
//============================================================================


struct  STT7213  {
  double fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT7213) C1{ FL FL:8 Fl}



static void Test_STT7213()
{
  {
    init_simple_test("STT7213");
    static STRUCT_IF_C STT7213 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7213)");
    check_field_offset(lv, fa, 0, "STT7213.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7213");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7213");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7213, STT7213)
//============================================================================


struct  STT7223  {
  double fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT7223) C1{ FL Fi:18 Fl}



static void Test_STT7223()
{
  {
    init_simple_test("STT7223");
    static STRUCT_IF_C STT7223 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7223)");
    check_field_offset(lv, fa, 0, "STT7223.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7223");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7223");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7223, STT7223)
//============================================================================


struct  STT7233  {
  double fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT7233) C1{ FL FL:18 Fl}



static void Test_STT7233()
{
  {
    init_simple_test("STT7233");
    static STRUCT_IF_C STT7233 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7233)");
    check_field_offset(lv, fa, 0, "STT7233.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7233");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7233");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7233, STT7233)
//============================================================================


struct  STT7243  {
  double fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT7243) C1{ FL FL:48 Fl}



static void Test_STT7243()
{
  {
    init_simple_test("STT7243");
    static STRUCT_IF_C STT7243 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7243)");
    check_field_offset(lv, fa, 0, "STT7243.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7243");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7243");
    check_field_offset(lv, fb, 16, "STT7243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7243, STT7243)
//============================================================================


struct  STT714  {
  double fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT714) C1{ FL Fc:0 FL}



static void Test_STT714()
{
  {
    init_simple_test("STT714");
    static STRUCT_IF_C STT714 lv;
    check2(sizeof(lv), 16, "sizeof(STT714)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT714)");
    check_field_offset(lv, fa, 0, "STT714.fa");
    check_field_offset(lv, fb, 8, "STT714.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT714, STT714)
//============================================================================


struct  STT724  {
  double fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT724) C1{ FL Fs:0 FL}



static void Test_STT724()
{
  {
    init_simple_test("STT724");
    static STRUCT_IF_C STT724 lv;
    check2(sizeof(lv), 16, "sizeof(STT724)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT724)");
    check_field_offset(lv, fa, 0, "STT724.fa");
    check_field_offset(lv, fb, 8, "STT724.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT724, STT724)
//============================================================================


struct  STT734  {
  double fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT734) C1{ FL Fi:0 FL}



static void Test_STT734()
{
  {
    init_simple_test("STT734");
    static STRUCT_IF_C STT734 lv;
    check2(sizeof(lv), 16, "sizeof(STT734)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT734)");
    check_field_offset(lv, fa, 0, "STT734.fa");
    check_field_offset(lv, fb, 8, "STT734.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT734, STT734)
//============================================================================


struct  STT744  {
  double fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT744) C1{ FL FL:0 FL}



static void Test_STT744()
{
  {
    init_simple_test("STT744");
    static STRUCT_IF_C STT744 lv;
    check2(sizeof(lv), 16, "sizeof(STT744)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT744)");
    check_field_offset(lv, fa, 0, "STT744.fa");
    check_field_offset(lv, fb, 8, "STT744.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT744, STT744)
//============================================================================


struct  STT754  {
  double fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT754) C1{ FL Fc:3 FL}



static void Test_STT754()
{
  {
    init_simple_test("STT754");
    static STRUCT_IF_C STT754 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT754)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT754)");
    check_field_offset(lv, fa, 0, "STT754.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT754.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT754, STT754)
//============================================================================


struct  STT764  {
  double fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT764) C1{ FL Fs:3 FL}



static void Test_STT764()
{
  {
    init_simple_test("STT764");
    static STRUCT_IF_C STT764 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT764)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT764)");
    check_field_offset(lv, fa, 0, "STT764.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT764.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT764, STT764)
//============================================================================


struct  STT774  {
  double fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT774) C1{ FL Fi:3 FL}



static void Test_STT774()
{
  {
    init_simple_test("STT774");
    static STRUCT_IF_C STT774 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT774)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT774)");
    check_field_offset(lv, fa, 0, "STT774.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT774.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT774, STT774)
//============================================================================


struct  STT784  {
  double fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT784) C1{ FL FL:3 FL}



static void Test_STT784()
{
  {
    init_simple_test("STT784");
    static STRUCT_IF_C STT784 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT784)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT784)");
    check_field_offset(lv, fa, 0, "STT784.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT784.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT784, STT784)
//============================================================================


struct  STT794  {
  double fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT794) C1{ FL Fs:8 FL}



static void Test_STT794()
{
  {
    init_simple_test("STT794");
    static STRUCT_IF_C STT794 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT794)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT794)");
    check_field_offset(lv, fa, 0, "STT794.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT794.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT794, STT794)
//============================================================================


struct  STT7104  {
  double fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT7104) C1{ FL Fi:8 FL}



static void Test_STT7104()
{
  {
    init_simple_test("STT7104");
    static STRUCT_IF_C STT7104 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7104)");
    check_field_offset(lv, fa, 0, "STT7104.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7104, STT7104)
//============================================================================


struct  STT7114  {
  double fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT7114) C1{ FL FL:8 FL}



static void Test_STT7114()
{
  {
    init_simple_test("STT7114");
    static STRUCT_IF_C STT7114 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7114)");
    check_field_offset(lv, fa, 0, "STT7114.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7114, STT7114)
//============================================================================


struct  STT7124  {
  double fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT7124) C1{ FL Fi:18 FL}



static void Test_STT7124()
{
  {
    init_simple_test("STT7124");
    static STRUCT_IF_C STT7124 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7124)");
    check_field_offset(lv, fa, 0, "STT7124.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7124, STT7124)
//============================================================================


struct  STT7134  {
  double fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT7134) C1{ FL FL:18 FL}



static void Test_STT7134()
{
  {
    init_simple_test("STT7134");
    static STRUCT_IF_C STT7134 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7134)");
    check_field_offset(lv, fa, 0, "STT7134.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7134, STT7134)
//============================================================================


struct  STT7144  {
  double fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT7144) C1{ FL FL:48 FL}



static void Test_STT7144()
{
  {
    init_simple_test("STT7144");
    static STRUCT_IF_C STT7144 lv;
    check2(sizeof(lv), 24, "sizeof(STT7144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7144)");
    check_field_offset(lv, fa, 0, "STT7144.fa");
    check_field_offset(lv, fb, 16, "STT7144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7144, STT7144)
//============================================================================


struct  STT7154  {
  double fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT7154) C1{ FL Fc:3 FL}



static void Test_STT7154()
{
  {
    init_simple_test("STT7154");
    static STRUCT_IF_C STT7154 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7154)");
    check_field_offset(lv, fa, 0, "STT7154.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7154");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7154");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7154, STT7154)
//============================================================================


struct  STT7164  {
  double fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT7164) C1{ FL Fs:3 FL}



static void Test_STT7164()
{
  {
    init_simple_test("STT7164");
    static STRUCT_IF_C STT7164 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7164)");
    check_field_offset(lv, fa, 0, "STT7164.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7164");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7164");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7164, STT7164)
//============================================================================


struct  STT7174  {
  double fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT7174) C1{ FL Fi:3 FL}



static void Test_STT7174()
{
  {
    init_simple_test("STT7174");
    static STRUCT_IF_C STT7174 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7174)");
    check_field_offset(lv, fa, 0, "STT7174.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7174");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7174");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7174, STT7174)
//============================================================================


struct  STT7184  {
  double fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT7184) C1{ FL FL:3 FL}



static void Test_STT7184()
{
  {
    init_simple_test("STT7184");
    static STRUCT_IF_C STT7184 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7184)");
    check_field_offset(lv, fa, 0, "STT7184.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7184");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7184");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7184, STT7184)
//============================================================================


struct  STT7194  {
  double fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT7194) C1{ FL Fs:8 FL}



static void Test_STT7194()
{
  {
    init_simple_test("STT7194");
    static STRUCT_IF_C STT7194 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7194)");
    check_field_offset(lv, fa, 0, "STT7194.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7194");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7194");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7194, STT7194)
//============================================================================


struct  STT7204  {
  double fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT7204) C1{ FL Fi:8 FL}



static void Test_STT7204()
{
  {
    init_simple_test("STT7204");
    static STRUCT_IF_C STT7204 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7204)");
    check_field_offset(lv, fa, 0, "STT7204.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7204");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7204");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7204, STT7204)
//============================================================================


struct  STT7214  {
  double fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT7214) C1{ FL FL:8 FL}



static void Test_STT7214()
{
  {
    init_simple_test("STT7214");
    static STRUCT_IF_C STT7214 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7214)");
    check_field_offset(lv, fa, 0, "STT7214.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7214");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7214");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7214, STT7214)
//============================================================================


struct  STT7224  {
  double fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT7224) C1{ FL Fi:18 FL}



static void Test_STT7224()
{
  {
    init_simple_test("STT7224");
    static STRUCT_IF_C STT7224 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7224)");
    check_field_offset(lv, fa, 0, "STT7224.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7224");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7224");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7224, STT7224)
//============================================================================


struct  STT7234  {
  double fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT7234) C1{ FL FL:18 FL}



static void Test_STT7234()
{
  {
    init_simple_test("STT7234");
    static STRUCT_IF_C STT7234 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7234)");
    check_field_offset(lv, fa, 0, "STT7234.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7234");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7234");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7234, STT7234)
//============================================================================


struct  STT7244  {
  double fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT7244) C1{ FL FL:48 FL}



static void Test_STT7244()
{
  {
    init_simple_test("STT7244");
    static STRUCT_IF_C STT7244 lv;
    check2(sizeof(lv), 24, "sizeof(STT7244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7244)");
    check_field_offset(lv, fa, 0, "STT7244.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7244");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7244");
    check_field_offset(lv, fb, 16, "STT7244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7244, STT7244)
//============================================================================


struct  STT715  {
  double fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT715) C1{ FL Fc:0 Fp}



static void Test_STT715()
{
  {
    init_simple_test("STT715");
    static STRUCT_IF_C STT715 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT715)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT715)");
    check_field_offset(lv, fa, 0, "STT715.fa");
    check_field_offset(lv, fb, 8, "STT715.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT715, STT715)
//============================================================================


struct  STT725  {
  double fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT725) C1{ FL Fs:0 Fp}



static void Test_STT725()
{
  {
    init_simple_test("STT725");
    static STRUCT_IF_C STT725 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT725)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT725)");
    check_field_offset(lv, fa, 0, "STT725.fa");
    check_field_offset(lv, fb, 8, "STT725.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT725, STT725)
//============================================================================


struct  STT735  {
  double fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT735) C1{ FL Fi:0 Fp}



static void Test_STT735()
{
  {
    init_simple_test("STT735");
    static STRUCT_IF_C STT735 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT735)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT735)");
    check_field_offset(lv, fa, 0, "STT735.fa");
    check_field_offset(lv, fb, 8, "STT735.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT735, STT735)
//============================================================================


struct  STT745  {
  double fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT745) C1{ FL FL:0 Fp}



static void Test_STT745()
{
  {
    init_simple_test("STT745");
    static STRUCT_IF_C STT745 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT745)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT745)");
    check_field_offset(lv, fa, 0, "STT745.fa");
    check_field_offset(lv, fb, 8, "STT745.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT745, STT745)
//============================================================================


struct  STT755  {
  double fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT755) C1{ FL Fc:3 Fp}



static void Test_STT755()
{
  {
    init_simple_test("STT755");
    static STRUCT_IF_C STT755 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT755)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT755)");
    check_field_offset(lv, fa, 0, "STT755.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT755.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT755, STT755)
//============================================================================


struct  STT765  {
  double fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT765) C1{ FL Fs:3 Fp}



static void Test_STT765()
{
  {
    init_simple_test("STT765");
    static STRUCT_IF_C STT765 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT765)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT765)");
    check_field_offset(lv, fa, 0, "STT765.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT765.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT765, STT765)
//============================================================================


struct  STT775  {
  double fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT775) C1{ FL Fi:3 Fp}



static void Test_STT775()
{
  {
    init_simple_test("STT775");
    static STRUCT_IF_C STT775 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT775)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT775)");
    check_field_offset(lv, fa, 0, "STT775.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT775.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT775, STT775)
//============================================================================


struct  STT785  {
  double fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT785) C1{ FL FL:3 Fp}



static void Test_STT785()
{
  {
    init_simple_test("STT785");
    static STRUCT_IF_C STT785 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT785)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT785)");
    check_field_offset(lv, fa, 0, "STT785.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT785.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT785, STT785)
//============================================================================


struct  STT795  {
  double fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT795) C1{ FL Fs:8 Fp}



static void Test_STT795()
{
  {
    init_simple_test("STT795");
    static STRUCT_IF_C STT795 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT795)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT795)");
    check_field_offset(lv, fa, 0, "STT795.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT795.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT795, STT795)
//============================================================================


struct  STT7105  {
  double fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT7105) C1{ FL Fi:8 Fp}



static void Test_STT7105()
{
  {
    init_simple_test("STT7105");
    static STRUCT_IF_C STT7105 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7105)");
    check_field_offset(lv, fa, 0, "STT7105.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7105, STT7105)
//============================================================================


struct  STT7115  {
  double fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT7115) C1{ FL FL:8 Fp}



static void Test_STT7115()
{
  {
    init_simple_test("STT7115");
    static STRUCT_IF_C STT7115 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7115)");
    check_field_offset(lv, fa, 0, "STT7115.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7115, STT7115)
//============================================================================


struct  STT7125  {
  double fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT7125) C1{ FL Fi:18 Fp}



static void Test_STT7125()
{
  {
    init_simple_test("STT7125");
    static STRUCT_IF_C STT7125 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7125)");
    check_field_offset(lv, fa, 0, "STT7125.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7125, STT7125)
//============================================================================


struct  STT7135  {
  double fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT7135) C1{ FL FL:18 Fp}



static void Test_STT7135()
{
  {
    init_simple_test("STT7135");
    static STRUCT_IF_C STT7135 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7135)");
    check_field_offset(lv, fa, 0, "STT7135.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7135, STT7135)
//============================================================================


struct  STT7145  {
  double fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT7145) C1{ FL FL:48 Fp}



static void Test_STT7145()
{
  {
    init_simple_test("STT7145");
    static STRUCT_IF_C STT7145 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7145)");
    check_field_offset(lv, fa, 0, "STT7145.fa");
    check_field_offset(lv, fb, 16, "STT7145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7145, STT7145)
//============================================================================


struct  STT7155  {
  double fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT7155) C1{ FL Fc:3 Fp}



static void Test_STT7155()
{
  {
    init_simple_test("STT7155");
    static STRUCT_IF_C STT7155 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7155)");
    check_field_offset(lv, fa, 0, "STT7155.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7155");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7155");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7155, STT7155)
//============================================================================


struct  STT7165  {
  double fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT7165) C1{ FL Fs:3 Fp}



static void Test_STT7165()
{
  {
    init_simple_test("STT7165");
    static STRUCT_IF_C STT7165 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7165)");
    check_field_offset(lv, fa, 0, "STT7165.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7165");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7165");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7165, STT7165)
//============================================================================


struct  STT7175  {
  double fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT7175) C1{ FL Fi:3 Fp}



static void Test_STT7175()
{
  {
    init_simple_test("STT7175");
    static STRUCT_IF_C STT7175 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7175)");
    check_field_offset(lv, fa, 0, "STT7175.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7175");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7175");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7175, STT7175)
//============================================================================


struct  STT7185  {
  double fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT7185) C1{ FL FL:3 Fp}



static void Test_STT7185()
{
  {
    init_simple_test("STT7185");
    static STRUCT_IF_C STT7185 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7185)");
    check_field_offset(lv, fa, 0, "STT7185.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7185");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7185");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7185, STT7185)
//============================================================================


struct  STT7195  {
  double fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT7195) C1{ FL Fs:8 Fp}



static void Test_STT7195()
{
  {
    init_simple_test("STT7195");
    static STRUCT_IF_C STT7195 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7195)");
    check_field_offset(lv, fa, 0, "STT7195.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7195");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7195");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7195, STT7195)
//============================================================================


struct  STT7205  {
  double fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT7205) C1{ FL Fi:8 Fp}



static void Test_STT7205()
{
  {
    init_simple_test("STT7205");
    static STRUCT_IF_C STT7205 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7205)");
    check_field_offset(lv, fa, 0, "STT7205.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7205");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7205");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7205, STT7205)
//============================================================================


struct  STT7215  {
  double fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT7215) C1{ FL FL:8 Fp}



static void Test_STT7215()
{
  {
    init_simple_test("STT7215");
    static STRUCT_IF_C STT7215 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7215)");
    check_field_offset(lv, fa, 0, "STT7215.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7215");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7215");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7215, STT7215)
//============================================================================


struct  STT7225  {
  double fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT7225) C1{ FL Fi:18 Fp}



static void Test_STT7225()
{
  {
    init_simple_test("STT7225");
    static STRUCT_IF_C STT7225 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7225)");
    check_field_offset(lv, fa, 0, "STT7225.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7225");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7225");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7225, STT7225)
//============================================================================


struct  STT7235  {
  double fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT7235) C1{ FL FL:18 Fp}



static void Test_STT7235()
{
  {
    init_simple_test("STT7235");
    static STRUCT_IF_C STT7235 lv;
    check2(sizeof(lv), ABISELECT(24,16), "sizeof(STT7235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7235)");
    check_field_offset(lv, fa, 0, "STT7235.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7235");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7235");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7235, STT7235)
//============================================================================


struct  STT7245  {
  double fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT7245) C1{ FL FL:48 Fp}



static void Test_STT7245()
{
  {
    init_simple_test("STT7245");
    static STRUCT_IF_C STT7245 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7245)");
    check_field_offset(lv, fa, 0, "STT7245.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7245");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7245");
    check_field_offset(lv, fb, 16, "STT7245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7245, STT7245)
//============================================================================


struct  STT716  {
  double fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT716) C1{ FL Fc:0 Fi}



static void Test_STT716()
{
  {
    init_simple_test("STT716");
    static STRUCT_IF_C STT716 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT716)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT716)");
    check_field_offset(lv, fa, 0, "STT716.fa");
    check_field_offset(lv, fb, 8, "STT716.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT716, STT716)
//============================================================================


struct  STT726  {
  double fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT726) C1{ FL Fs:0 Fi}



static void Test_STT726()
{
  {
    init_simple_test("STT726");
    static STRUCT_IF_C STT726 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT726)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT726)");
    check_field_offset(lv, fa, 0, "STT726.fa");
    check_field_offset(lv, fb, 8, "STT726.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT726, STT726)
//============================================================================


struct  STT736  {
  double fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT736) C1{ FL Fi:0 Fi}



static void Test_STT736()
{
  {
    init_simple_test("STT736");
    static STRUCT_IF_C STT736 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT736)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT736)");
    check_field_offset(lv, fa, 0, "STT736.fa");
    check_field_offset(lv, fb, 8, "STT736.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT736, STT736)
//============================================================================


struct  STT746  {
  double fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT746) C1{ FL FL:0 Fi}



static void Test_STT746()
{
  {
    init_simple_test("STT746");
    static STRUCT_IF_C STT746 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT746)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT746)");
    check_field_offset(lv, fa, 0, "STT746.fa");
    check_field_offset(lv, fb, 8, "STT746.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT746, STT746)
//============================================================================


struct  STT756  {
  double fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT756) C1{ FL Fc:3 Fi}



static void Test_STT756()
{
  {
    init_simple_test("STT756");
    static STRUCT_IF_C STT756 lv;
    check2(sizeof(lv), 16, "sizeof(STT756)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT756)");
    check_field_offset(lv, fa, 0, "STT756.fa");
    check_field_offset(lv, fb, 12, "STT756.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT756, STT756)
//============================================================================


struct  STT766  {
  double fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT766) C1{ FL Fs:3 Fi}



static void Test_STT766()
{
  {
    init_simple_test("STT766");
    static STRUCT_IF_C STT766 lv;
    check2(sizeof(lv), 16, "sizeof(STT766)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT766)");
    check_field_offset(lv, fa, 0, "STT766.fa");
    check_field_offset(lv, fb, 12, "STT766.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT766, STT766)
//============================================================================


struct  STT776  {
  double fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT776) C1{ FL Fi:3 Fi}



static void Test_STT776()
{
  {
    init_simple_test("STT776");
    static STRUCT_IF_C STT776 lv;
    check2(sizeof(lv), 16, "sizeof(STT776)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT776)");
    check_field_offset(lv, fa, 0, "STT776.fa");
    check_field_offset(lv, fb, 12, "STT776.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT776, STT776)
//============================================================================


struct  STT786  {
  double fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT786) C1{ FL FL:3 Fi}



static void Test_STT786()
{
  {
    init_simple_test("STT786");
    static STRUCT_IF_C STT786 lv;
    check2(sizeof(lv), 16, "sizeof(STT786)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT786)");
    check_field_offset(lv, fa, 0, "STT786.fa");
    check_field_offset(lv, fb, 12, "STT786.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT786, STT786)
//============================================================================


struct  STT796  {
  double fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT796) C1{ FL Fs:8 Fi}



static void Test_STT796()
{
  {
    init_simple_test("STT796");
    static STRUCT_IF_C STT796 lv;
    check2(sizeof(lv), 16, "sizeof(STT796)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT796)");
    check_field_offset(lv, fa, 0, "STT796.fa");
    check_field_offset(lv, fb, 12, "STT796.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT796, STT796)
//============================================================================


struct  STT7106  {
  double fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT7106) C1{ FL Fi:8 Fi}



static void Test_STT7106()
{
  {
    init_simple_test("STT7106");
    static STRUCT_IF_C STT7106 lv;
    check2(sizeof(lv), 16, "sizeof(STT7106)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7106)");
    check_field_offset(lv, fa, 0, "STT7106.fa");
    check_field_offset(lv, fb, 12, "STT7106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7106, STT7106)
//============================================================================


struct  STT7116  {
  double fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT7116) C1{ FL FL:8 Fi}



static void Test_STT7116()
{
  {
    init_simple_test("STT7116");
    static STRUCT_IF_C STT7116 lv;
    check2(sizeof(lv), 16, "sizeof(STT7116)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7116)");
    check_field_offset(lv, fa, 0, "STT7116.fa");
    check_field_offset(lv, fb, 12, "STT7116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7116, STT7116)
//============================================================================


struct  STT7126  {
  double fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT7126) C1{ FL Fi:18 Fi}



static void Test_STT7126()
{
  {
    init_simple_test("STT7126");
    static STRUCT_IF_C STT7126 lv;
    check2(sizeof(lv), 16, "sizeof(STT7126)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7126)");
    check_field_offset(lv, fa, 0, "STT7126.fa");
    check_field_offset(lv, fb, 12, "STT7126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7126, STT7126)
//============================================================================


struct  STT7136  {
  double fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT7136) C1{ FL FL:18 Fi}



static void Test_STT7136()
{
  {
    init_simple_test("STT7136");
    static STRUCT_IF_C STT7136 lv;
    check2(sizeof(lv), 16, "sizeof(STT7136)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7136)");
    check_field_offset(lv, fa, 0, "STT7136.fa");
    check_field_offset(lv, fb, 12, "STT7136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7136, STT7136)
//============================================================================


struct  STT7146  {
  double fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT7146) C1{ FL FL:48 Fi}



static void Test_STT7146()
{
  {
    init_simple_test("STT7146");
    static STRUCT_IF_C STT7146 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7146)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7146)");
    check_field_offset(lv, fa, 0, "STT7146.fa");
    check_field_offset(lv, fb, 16, "STT7146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7146, STT7146)
//============================================================================


struct  STT7156  {
  double fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT7156) C1{ FL Fc:3 Fi}



static void Test_STT7156()
{
  {
    init_simple_test("STT7156");
    static STRUCT_IF_C STT7156 lv;
    check2(sizeof(lv), 16, "sizeof(STT7156)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7156)");
    check_field_offset(lv, fa, 0, "STT7156.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7156");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7156");
    check_field_offset(lv, fb, 12, "STT7156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7156, STT7156)
//============================================================================


struct  STT7166  {
  double fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT7166) C1{ FL Fs:3 Fi}



static void Test_STT7166()
{
  {
    init_simple_test("STT7166");
    static STRUCT_IF_C STT7166 lv;
    check2(sizeof(lv), 16, "sizeof(STT7166)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7166)");
    check_field_offset(lv, fa, 0, "STT7166.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7166");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7166");
    check_field_offset(lv, fb, 12, "STT7166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7166, STT7166)
//============================================================================


struct  STT7176  {
  double fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT7176) C1{ FL Fi:3 Fi}



static void Test_STT7176()
{
  {
    init_simple_test("STT7176");
    static STRUCT_IF_C STT7176 lv;
    check2(sizeof(lv), 16, "sizeof(STT7176)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7176)");
    check_field_offset(lv, fa, 0, "STT7176.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7176");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7176");
    check_field_offset(lv, fb, 12, "STT7176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7176, STT7176)
//============================================================================


struct  STT7186  {
  double fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT7186) C1{ FL FL:3 Fi}



static void Test_STT7186()
{
  {
    init_simple_test("STT7186");
    static STRUCT_IF_C STT7186 lv;
    check2(sizeof(lv), 16, "sizeof(STT7186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7186)");
    check_field_offset(lv, fa, 0, "STT7186.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7186");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7186");
    check_field_offset(lv, fb, 12, "STT7186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7186, STT7186)
//============================================================================


struct  STT7196  {
  double fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT7196) C1{ FL Fs:8 Fi}



static void Test_STT7196()
{
  {
    init_simple_test("STT7196");
    static STRUCT_IF_C STT7196 lv;
    check2(sizeof(lv), 16, "sizeof(STT7196)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7196)");
    check_field_offset(lv, fa, 0, "STT7196.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7196");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7196");
    check_field_offset(lv, fb, 12, "STT7196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7196, STT7196)
//============================================================================


struct  STT7206  {
  double fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT7206) C1{ FL Fi:8 Fi}



static void Test_STT7206()
{
  {
    init_simple_test("STT7206");
    static STRUCT_IF_C STT7206 lv;
    check2(sizeof(lv), 16, "sizeof(STT7206)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7206)");
    check_field_offset(lv, fa, 0, "STT7206.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7206");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7206");
    check_field_offset(lv, fb, 12, "STT7206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7206, STT7206)
//============================================================================


struct  STT7216  {
  double fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT7216) C1{ FL FL:8 Fi}



static void Test_STT7216()
{
  {
    init_simple_test("STT7216");
    static STRUCT_IF_C STT7216 lv;
    check2(sizeof(lv), 16, "sizeof(STT7216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7216)");
    check_field_offset(lv, fa, 0, "STT7216.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7216");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7216");
    check_field_offset(lv, fb, 12, "STT7216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7216, STT7216)
//============================================================================


struct  STT7226  {
  double fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT7226) C1{ FL Fi:18 Fi}



static void Test_STT7226()
{
  {
    init_simple_test("STT7226");
    static STRUCT_IF_C STT7226 lv;
    check2(sizeof(lv), 16, "sizeof(STT7226)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7226)");
    check_field_offset(lv, fa, 0, "STT7226.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7226");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7226");
    check_field_offset(lv, fb, 12, "STT7226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7226, STT7226)
//============================================================================


struct  STT7236  {
  double fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT7236) C1{ FL FL:18 Fi}



static void Test_STT7236()
{
  {
    init_simple_test("STT7236");
    static STRUCT_IF_C STT7236 lv;
    check2(sizeof(lv), 16, "sizeof(STT7236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7236)");
    check_field_offset(lv, fa, 0, "STT7236.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7236");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7236");
    check_field_offset(lv, fb, 12, "STT7236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7236, STT7236)
//============================================================================


struct  STT7246  {
  double fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT7246) C1{ FL FL:48 Fi}



static void Test_STT7246()
{
  {
    init_simple_test("STT7246");
    static STRUCT_IF_C STT7246 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7246)");
    check_field_offset(lv, fa, 0, "STT7246.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7246");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7246");
    check_field_offset(lv, fb, 16, "STT7246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7246, STT7246)
//============================================================================


struct  STT717  {
  double fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT717) C1{ FL Fc:0 FL}



static void Test_STT717()
{
  {
    init_simple_test("STT717");
    static STRUCT_IF_C STT717 lv;
    check2(sizeof(lv), 16, "sizeof(STT717)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT717)");
    check_field_offset(lv, fa, 0, "STT717.fa");
    check_field_offset(lv, fb, 8, "STT717.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT717, STT717)
//============================================================================


struct  STT727  {
  double fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT727) C1{ FL Fs:0 FL}



static void Test_STT727()
{
  {
    init_simple_test("STT727");
    static STRUCT_IF_C STT727 lv;
    check2(sizeof(lv), 16, "sizeof(STT727)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT727)");
    check_field_offset(lv, fa, 0, "STT727.fa");
    check_field_offset(lv, fb, 8, "STT727.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT727, STT727)
//============================================================================


struct  STT737  {
  double fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT737) C1{ FL Fi:0 FL}



static void Test_STT737()
{
  {
    init_simple_test("STT737");
    static STRUCT_IF_C STT737 lv;
    check2(sizeof(lv), 16, "sizeof(STT737)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT737)");
    check_field_offset(lv, fa, 0, "STT737.fa");
    check_field_offset(lv, fb, 8, "STT737.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT737, STT737)
//============================================================================


struct  STT747  {
  double fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT747) C1{ FL FL:0 FL}



static void Test_STT747()
{
  {
    init_simple_test("STT747");
    static STRUCT_IF_C STT747 lv;
    check2(sizeof(lv), 16, "sizeof(STT747)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT747)");
    check_field_offset(lv, fa, 0, "STT747.fa");
    check_field_offset(lv, fb, 8, "STT747.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT747, STT747)
//============================================================================


struct  STT757  {
  double fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT757) C1{ FL Fc:3 FL}



static void Test_STT757()
{
  {
    init_simple_test("STT757");
    static STRUCT_IF_C STT757 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT757)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT757)");
    check_field_offset(lv, fa, 0, "STT757.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT757.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT757, STT757)
//============================================================================


struct  STT767  {
  double fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT767) C1{ FL Fs:3 FL}



static void Test_STT767()
{
  {
    init_simple_test("STT767");
    static STRUCT_IF_C STT767 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT767)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT767)");
    check_field_offset(lv, fa, 0, "STT767.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT767.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT767, STT767)
//============================================================================


struct  STT777  {
  double fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT777) C1{ FL Fi:3 FL}



static void Test_STT777()
{
  {
    init_simple_test("STT777");
    static STRUCT_IF_C STT777 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT777)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT777)");
    check_field_offset(lv, fa, 0, "STT777.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT777.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT777, STT777)
//============================================================================


struct  STT787  {
  double fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT787) C1{ FL FL:3 FL}



static void Test_STT787()
{
  {
    init_simple_test("STT787");
    static STRUCT_IF_C STT787 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT787)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT787)");
    check_field_offset(lv, fa, 0, "STT787.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT787.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT787, STT787)
//============================================================================


struct  STT797  {
  double fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT797) C1{ FL Fs:8 FL}



static void Test_STT797()
{
  {
    init_simple_test("STT797");
    static STRUCT_IF_C STT797 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT797)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT797)");
    check_field_offset(lv, fa, 0, "STT797.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT797.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT797, STT797)
//============================================================================


struct  STT7107  {
  double fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT7107) C1{ FL Fi:8 FL}



static void Test_STT7107()
{
  {
    init_simple_test("STT7107");
    static STRUCT_IF_C STT7107 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7107)");
    check_field_offset(lv, fa, 0, "STT7107.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7107, STT7107)
//============================================================================


struct  STT7117  {
  double fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT7117) C1{ FL FL:8 FL}



static void Test_STT7117()
{
  {
    init_simple_test("STT7117");
    static STRUCT_IF_C STT7117 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7117)");
    check_field_offset(lv, fa, 0, "STT7117.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7117, STT7117)
//============================================================================


struct  STT7127  {
  double fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT7127) C1{ FL Fi:18 FL}



static void Test_STT7127()
{
  {
    init_simple_test("STT7127");
    static STRUCT_IF_C STT7127 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7127)");
    check_field_offset(lv, fa, 0, "STT7127.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7127, STT7127)
//============================================================================


struct  STT7137  {
  double fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT7137) C1{ FL FL:18 FL}



static void Test_STT7137()
{
  {
    init_simple_test("STT7137");
    static STRUCT_IF_C STT7137 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7137)");
    check_field_offset(lv, fa, 0, "STT7137.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7137, STT7137)
//============================================================================


struct  STT7147  {
  double fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT7147) C1{ FL FL:48 FL}



static void Test_STT7147()
{
  {
    init_simple_test("STT7147");
    static STRUCT_IF_C STT7147 lv;
    check2(sizeof(lv), 24, "sizeof(STT7147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7147)");
    check_field_offset(lv, fa, 0, "STT7147.fa");
    check_field_offset(lv, fb, 16, "STT7147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7147, STT7147)
//============================================================================


struct  STT7157  {
  double fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT7157) C1{ FL Fc:3 FL}



static void Test_STT7157()
{
  {
    init_simple_test("STT7157");
    static STRUCT_IF_C STT7157 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7157)");
    check_field_offset(lv, fa, 0, "STT7157.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7157");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7157");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7157, STT7157)
//============================================================================


struct  STT7167  {
  double fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT7167) C1{ FL Fs:3 FL}



static void Test_STT7167()
{
  {
    init_simple_test("STT7167");
    static STRUCT_IF_C STT7167 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7167)");
    check_field_offset(lv, fa, 0, "STT7167.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7167");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7167");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7167, STT7167)
//============================================================================


struct  STT7177  {
  double fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT7177) C1{ FL Fi:3 FL}



static void Test_STT7177()
{
  {
    init_simple_test("STT7177");
    static STRUCT_IF_C STT7177 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7177)");
    check_field_offset(lv, fa, 0, "STT7177.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7177");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7177");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7177, STT7177)
//============================================================================


struct  STT7187  {
  double fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT7187) C1{ FL FL:3 FL}



static void Test_STT7187()
{
  {
    init_simple_test("STT7187");
    static STRUCT_IF_C STT7187 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7187)");
    check_field_offset(lv, fa, 0, "STT7187.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7187");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7187");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7187, STT7187)
//============================================================================


struct  STT7197  {
  double fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT7197) C1{ FL Fs:8 FL}



static void Test_STT7197()
{
  {
    init_simple_test("STT7197");
    static STRUCT_IF_C STT7197 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7197)");
    check_field_offset(lv, fa, 0, "STT7197.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7197");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7197");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7197, STT7197)
//============================================================================


struct  STT7207  {
  double fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT7207) C1{ FL Fi:8 FL}



static void Test_STT7207()
{
  {
    init_simple_test("STT7207");
    static STRUCT_IF_C STT7207 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7207)");
    check_field_offset(lv, fa, 0, "STT7207.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7207");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7207");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7207, STT7207)
//============================================================================


struct  STT7217  {
  double fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT7217) C1{ FL FL:8 FL}



static void Test_STT7217()
{
  {
    init_simple_test("STT7217");
    static STRUCT_IF_C STT7217 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7217)");
    check_field_offset(lv, fa, 0, "STT7217.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7217");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7217");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7217, STT7217)
//============================================================================


struct  STT7227  {
  double fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT7227) C1{ FL Fi:18 FL}



static void Test_STT7227()
{
  {
    init_simple_test("STT7227");
    static STRUCT_IF_C STT7227 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7227)");
    check_field_offset(lv, fa, 0, "STT7227.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7227");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7227");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7227, STT7227)
//============================================================================


struct  STT7237  {
  double fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT7237) C1{ FL FL:18 FL}



static void Test_STT7237()
{
  {
    init_simple_test("STT7237");
    static STRUCT_IF_C STT7237 lv;
    check2(sizeof(lv), ABISELECT(24,20), "sizeof(STT7237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7237)");
    check_field_offset(lv, fa, 0, "STT7237.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7237");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7237");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7237, STT7237)
//============================================================================


struct  STT7247  {
  double fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT7247) C1{ FL FL:48 FL}



static void Test_STT7247()
{
  {
    init_simple_test("STT7247");
    static STRUCT_IF_C STT7247 lv;
    check2(sizeof(lv), 24, "sizeof(STT7247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7247)");
    check_field_offset(lv, fa, 0, "STT7247.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7247");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7247");
    check_field_offset(lv, fb, 16, "STT7247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7247, STT7247)
//============================================================================


struct  STT718  {
  double fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT718) C1{ FL Fc:0 FD}



static void Test_STT718()
{
  {
    init_simple_test("STT718");
    static STRUCT_IF_C STT718 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT718)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT718)");
    check_field_offset(lv, fa, 0, "STT718.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT718.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT718, STT718)
//============================================================================


struct  STT728  {
  double fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT728) C1{ FL Fs:0 FD}



static void Test_STT728()
{
  {
    init_simple_test("STT728");
    static STRUCT_IF_C STT728 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT728)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT728)");
    check_field_offset(lv, fa, 0, "STT728.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT728.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT728, STT728)
//============================================================================


struct  STT738  {
  double fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT738) C1{ FL Fi:0 FD}



static void Test_STT738()
{
  {
    init_simple_test("STT738");
    static STRUCT_IF_C STT738 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT738)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT738)");
    check_field_offset(lv, fa, 0, "STT738.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT738.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT738, STT738)
//============================================================================


struct  STT748  {
  double fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT748) C1{ FL FL:0 FD}



static void Test_STT748()
{
  {
    init_simple_test("STT748");
    static STRUCT_IF_C STT748 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT748)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT748)");
    check_field_offset(lv, fa, 0, "STT748.fa");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT748.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT748, STT748)
//============================================================================


struct  STT758  {
  double fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT758) C1{ FL Fc:3 FD}



static void Test_STT758()
{
  {
    init_simple_test("STT758");
    static STRUCT_IF_C STT758 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT758)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT758)");
    check_field_offset(lv, fa, 0, "STT758.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT758.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT758, STT758)
//============================================================================


struct  STT768  {
  double fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT768) C1{ FL Fs:3 FD}



static void Test_STT768()
{
  {
    init_simple_test("STT768");
    static STRUCT_IF_C STT768 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT768)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT768)");
    check_field_offset(lv, fa, 0, "STT768.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT768.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT768, STT768)
//============================================================================


struct  STT778  {
  double fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT778) C1{ FL Fi:3 FD}



static void Test_STT778()
{
  {
    init_simple_test("STT778");
    static STRUCT_IF_C STT778 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT778)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT778)");
    check_field_offset(lv, fa, 0, "STT778.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT778.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT778, STT778)
//============================================================================


struct  STT788  {
  double fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT788) C1{ FL FL:3 FD}



static void Test_STT788()
{
  {
    init_simple_test("STT788");
    static STRUCT_IF_C STT788 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT788)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT788)");
    check_field_offset(lv, fa, 0, "STT788.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT788.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT788, STT788)
//============================================================================


struct  STT798  {
  double fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT798) C1{ FL Fs:8 FD}



static void Test_STT798()
{
  {
    init_simple_test("STT798");
    static STRUCT_IF_C STT798 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT798)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT798)");
    check_field_offset(lv, fa, 0, "STT798.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT798.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT798, STT798)
//============================================================================


struct  STT7108  {
  double fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT7108) C1{ FL Fi:8 FD}



static void Test_STT7108()
{
  {
    init_simple_test("STT7108");
    static STRUCT_IF_C STT7108 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7108)");
    check_field_offset(lv, fa, 0, "STT7108.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7108, STT7108)
//============================================================================


struct  STT7118  {
  double fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT7118) C1{ FL FL:8 FD}



static void Test_STT7118()
{
  {
    init_simple_test("STT7118");
    static STRUCT_IF_C STT7118 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7118)");
    check_field_offset(lv, fa, 0, "STT7118.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7118, STT7118)
//============================================================================


struct  STT7128  {
  double fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT7128) C1{ FL Fi:18 FD}



static void Test_STT7128()
{
  {
    init_simple_test("STT7128");
    static STRUCT_IF_C STT7128 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7128)");
    check_field_offset(lv, fa, 0, "STT7128.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7128, STT7128)
//============================================================================


struct  STT7138  {
  double fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT7138) C1{ FL FL:18 FD}



static void Test_STT7138()
{
  {
    init_simple_test("STT7138");
    static STRUCT_IF_C STT7138 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7138)");
    check_field_offset(lv, fa, 0, "STT7138.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7138, STT7138)
//============================================================================


struct  STT7148  {
  double fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT7148) C1{ FL FL:48 FD}



static void Test_STT7148()
{
  {
    init_simple_test("STT7148");
    static STRUCT_IF_C STT7148 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT7148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7148)");
    check_field_offset(lv, fa, 0, "STT7148.fa");
    check_field_offset(lv, fb, 16, "STT7148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7148, STT7148)
//============================================================================


struct  STT7158  {
  double fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT7158) C1{ FL Fc:3 FD}



static void Test_STT7158()
{
  {
    init_simple_test("STT7158");
    static STRUCT_IF_C STT7158 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7158)");
    check_field_offset(lv, fa, 0, "STT7158.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7158");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7158");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7158, STT7158)
//============================================================================


struct  STT7168  {
  double fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT7168) C1{ FL Fs:3 FD}



static void Test_STT7168()
{
  {
    init_simple_test("STT7168");
    static STRUCT_IF_C STT7168 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7168)");
    check_field_offset(lv, fa, 0, "STT7168.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7168");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7168");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7168, STT7168)
//============================================================================


struct  STT7178  {
  double fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT7178) C1{ FL Fi:3 FD}



static void Test_STT7178()
{
  {
    init_simple_test("STT7178");
    static STRUCT_IF_C STT7178 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7178)");
    check_field_offset(lv, fa, 0, "STT7178.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7178");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7178");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7178, STT7178)
//============================================================================


struct  STT7188  {
  double fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT7188) C1{ FL FL:3 FD}



static void Test_STT7188()
{
  {
    init_simple_test("STT7188");
    static STRUCT_IF_C STT7188 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7188)");
    check_field_offset(lv, fa, 0, "STT7188.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7188");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7188");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7188, STT7188)
//============================================================================


struct  STT7198  {
  double fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT7198) C1{ FL Fs:8 FD}



static void Test_STT7198()
{
  {
    init_simple_test("STT7198");
    static STRUCT_IF_C STT7198 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7198)");
    check_field_offset(lv, fa, 0, "STT7198.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7198");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7198");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7198, STT7198)
//============================================================================


struct  STT7208  {
  double fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT7208) C1{ FL Fi:8 FD}



static void Test_STT7208()
{
  {
    init_simple_test("STT7208");
    static STRUCT_IF_C STT7208 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7208)");
    check_field_offset(lv, fa, 0, "STT7208.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7208");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7208");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7208, STT7208)
//============================================================================


struct  STT7218  {
  double fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT7218) C1{ FL FL:8 FD}



static void Test_STT7218()
{
  {
    init_simple_test("STT7218");
    static STRUCT_IF_C STT7218 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7218)");
    check_field_offset(lv, fa, 0, "STT7218.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7218");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7218");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7218, STT7218)
//============================================================================


struct  STT7228  {
  double fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT7228) C1{ FL Fi:18 FD}



static void Test_STT7228()
{
  {
    init_simple_test("STT7228");
    static STRUCT_IF_C STT7228 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7228)");
    check_field_offset(lv, fa, 0, "STT7228.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7228");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7228");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7228, STT7228)
//============================================================================


struct  STT7238  {
  double fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT7238) C1{ FL FL:18 FD}



static void Test_STT7238()
{
  {
    init_simple_test("STT7238");
    static STRUCT_IF_C STT7238 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT7238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7238)");
    check_field_offset(lv, fa, 0, "STT7238.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7238");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7238");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT7238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7238, STT7238)
//============================================================================


struct  STT7248  {
  double fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT7248) C1{ FL FL:48 FD}



static void Test_STT7248()
{
  {
    init_simple_test("STT7248");
    static STRUCT_IF_C STT7248 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT7248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT7248)");
    check_field_offset(lv, fa, 0, "STT7248.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7248");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7248");
    check_field_offset(lv, fb, 16, "STT7248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7248, STT7248)
//============================================================================


struct  STT719  {
  double fa;
  unsigned char  :0;
};
//SIG(1 STT719) C1{ FL Fc:0}



static void Test_STT719()
{
  {
    init_simple_test("STT719");
    static STRUCT_IF_C STT719 lv;
    check2(sizeof(lv), 8, "sizeof(STT719)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT719)");
    check_field_offset(lv, fa, 0, "STT719.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT719, STT719)
//============================================================================


struct  STT729  {
  double fa;
  unsigned short  :0;
};
//SIG(1 STT729) C1{ FL Fs:0}



static void Test_STT729()
{
  {
    init_simple_test("STT729");
    static STRUCT_IF_C STT729 lv;
    check2(sizeof(lv), 8, "sizeof(STT729)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT729)");
    check_field_offset(lv, fa, 0, "STT729.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT729, STT729)
//============================================================================


struct  STT739  {
  double fa;
  unsigned int  :0;
};
//SIG(1 STT739) C1{ FL Fi:0}



static void Test_STT739()
{
  {
    init_simple_test("STT739");
    static STRUCT_IF_C STT739 lv;
    check2(sizeof(lv), 8, "sizeof(STT739)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT739)");
    check_field_offset(lv, fa, 0, "STT739.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT739, STT739)
//============================================================================


struct  STT749  {
  double fa;
  __tsu64  :0;
};
//SIG(1 STT749) C1{ FL FL:0}



static void Test_STT749()
{
  {
    init_simple_test("STT749");
    static STRUCT_IF_C STT749 lv;
    check2(sizeof(lv), 8, "sizeof(STT749)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT749)");
    check_field_offset(lv, fa, 0, "STT749.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT749, STT749)
//============================================================================


struct  STT759  {
  double fa;
  unsigned char  :3;
};
//SIG(1 STT759) C1{ FL Fc:3}



static void Test_STT759()
{
  {
    init_simple_test("STT759");
    static STRUCT_IF_C STT759 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT759)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT759)");
    check_field_offset(lv, fa, 0, "STT759.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT759, STT759)
//============================================================================


struct  STT769  {
  double fa;
  unsigned short  :3;
};
//SIG(1 STT769) C1{ FL Fs:3}



static void Test_STT769()
{
  {
    init_simple_test("STT769");
    static STRUCT_IF_C STT769 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT769)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT769)");
    check_field_offset(lv, fa, 0, "STT769.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT769, STT769)
//============================================================================


struct  STT779  {
  double fa;
  unsigned int  :3;
};
//SIG(1 STT779) C1{ FL Fi:3}



static void Test_STT779()
{
  {
    init_simple_test("STT779");
    static STRUCT_IF_C STT779 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT779)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT779)");
    check_field_offset(lv, fa, 0, "STT779.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT779, STT779)
//============================================================================


struct  STT789  {
  double fa;
  __tsu64  :3;
};
//SIG(1 STT789) C1{ FL FL:3}



static void Test_STT789()
{
  {
    init_simple_test("STT789");
    static STRUCT_IF_C STT789 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT789)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT789)");
    check_field_offset(lv, fa, 0, "STT789.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT789, STT789)
//============================================================================


struct  STT799  {
  double fa;
  unsigned short  :8;
};
//SIG(1 STT799) C1{ FL Fs:8}



static void Test_STT799()
{
  {
    init_simple_test("STT799");
    static STRUCT_IF_C STT799 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT799)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT799)");
    check_field_offset(lv, fa, 0, "STT799.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT799, STT799)
//============================================================================


struct  STT7109  {
  double fa;
  unsigned int  :8;
};
//SIG(1 STT7109) C1{ FL Fi:8}



static void Test_STT7109()
{
  {
    init_simple_test("STT7109");
    static STRUCT_IF_C STT7109 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7109)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7109)");
    check_field_offset(lv, fa, 0, "STT7109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7109, STT7109)
//============================================================================


struct  STT7119  {
  double fa;
  __tsu64  :8;
};
//SIG(1 STT7119) C1{ FL FL:8}



static void Test_STT7119()
{
  {
    init_simple_test("STT7119");
    static STRUCT_IF_C STT7119 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7119)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7119)");
    check_field_offset(lv, fa, 0, "STT7119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7119, STT7119)
//============================================================================


struct  STT7129  {
  double fa;
  unsigned int  :18;
};
//SIG(1 STT7129) C1{ FL Fi:18}



static void Test_STT7129()
{
  {
    init_simple_test("STT7129");
    static STRUCT_IF_C STT7129 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7129)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7129)");
    check_field_offset(lv, fa, 0, "STT7129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7129, STT7129)
//============================================================================


struct  STT7139  {
  double fa;
  __tsu64  :18;
};
//SIG(1 STT7139) C1{ FL FL:18}



static void Test_STT7139()
{
  {
    init_simple_test("STT7139");
    static STRUCT_IF_C STT7139 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7139)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7139)");
    check_field_offset(lv, fa, 0, "STT7139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7139, STT7139)
//============================================================================


struct  STT7149  {
  double fa;
  __tsu64  :48;
};
//SIG(1 STT7149) C1{ FL FL:48}



static void Test_STT7149()
{
  {
    init_simple_test("STT7149");
    static STRUCT_IF_C STT7149 lv;
    check2(sizeof(lv), 16, "sizeof(STT7149)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7149)");
    check_field_offset(lv, fa, 0, "STT7149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7149, STT7149)
//============================================================================


struct  STT7159  {
  double fa;
  unsigned char bf:3;
};
//SIG(1 STT7159) C1{ FL Fc:3}



static void Test_STT7159()
{
  {
    init_simple_test("STT7159");
    static STRUCT_IF_C STT7159 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7159)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7159)");
    check_field_offset(lv, fa, 0, "STT7159.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7159");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7159, STT7159)
//============================================================================


struct  STT7169  {
  double fa;
  unsigned short bf:3;
};
//SIG(1 STT7169) C1{ FL Fs:3}



static void Test_STT7169()
{
  {
    init_simple_test("STT7169");
    static STRUCT_IF_C STT7169 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7169)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7169)");
    check_field_offset(lv, fa, 0, "STT7169.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7169");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7169, STT7169)
//============================================================================


struct  STT7179  {
  double fa;
  unsigned int bf:3;
};
//SIG(1 STT7179) C1{ FL Fi:3}



static void Test_STT7179()
{
  {
    init_simple_test("STT7179");
    static STRUCT_IF_C STT7179 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7179)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7179)");
    check_field_offset(lv, fa, 0, "STT7179.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7179");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7179, STT7179)
//============================================================================


struct  STT7189  {
  double fa;
  __tsu64 bf:3;
};
//SIG(1 STT7189) C1{ FL FL:3}



static void Test_STT7189()
{
  {
    init_simple_test("STT7189");
    static STRUCT_IF_C STT7189 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7189)");
    check_field_offset(lv, fa, 0, "STT7189.fa");
    set_bf_and_test(lv, bf, 8, 0, 3, 1, "STT7189");
    set_bf_and_test(lv, bf, 8, 0, 3, hide_ull(1LL<<2), "STT7189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7189, STT7189)
//============================================================================


struct  STT7199  {
  double fa;
  unsigned short bf:8;
};
//SIG(1 STT7199) C1{ FL Fs:8}



static void Test_STT7199()
{
  {
    init_simple_test("STT7199");
    static STRUCT_IF_C STT7199 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7199)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7199)");
    check_field_offset(lv, fa, 0, "STT7199.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7199");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7199, STT7199)
//============================================================================


struct  STT7209  {
  double fa;
  unsigned int bf:8;
};
//SIG(1 STT7209) C1{ FL Fi:8}



static void Test_STT7209()
{
  {
    init_simple_test("STT7209");
    static STRUCT_IF_C STT7209 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7209)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7209)");
    check_field_offset(lv, fa, 0, "STT7209.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7209");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7209, STT7209)
//============================================================================


struct  STT7219  {
  double fa;
  __tsu64 bf:8;
};
//SIG(1 STT7219) C1{ FL FL:8}



static void Test_STT7219()
{
  {
    init_simple_test("STT7219");
    static STRUCT_IF_C STT7219 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7219)");
    check_field_offset(lv, fa, 0, "STT7219.fa");
    set_bf_and_test(lv, bf, 8, 0, 8, 1, "STT7219");
    set_bf_and_test(lv, bf, 8, 0, 8, hide_ull(1LL<<7), "STT7219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7219, STT7219)
//============================================================================


struct  STT7229  {
  double fa;
  unsigned int bf:18;
};
//SIG(1 STT7229) C1{ FL Fi:18}



static void Test_STT7229()
{
  {
    init_simple_test("STT7229");
    static STRUCT_IF_C STT7229 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7229)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7229)");
    check_field_offset(lv, fa, 0, "STT7229.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7229");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7229, STT7229)
//============================================================================


struct  STT7239  {
  double fa;
  __tsu64 bf:18;
};
//SIG(1 STT7239) C1{ FL FL:18}



static void Test_STT7239()
{
  {
    init_simple_test("STT7239");
    static STRUCT_IF_C STT7239 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT7239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7239)");
    check_field_offset(lv, fa, 0, "STT7239.fa");
    set_bf_and_test(lv, bf, 8, 0, 18, 1, "STT7239");
    set_bf_and_test(lv, bf, 8, 0, 18, hide_ull(1LL<<17), "STT7239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7239, STT7239)
//============================================================================


struct  STT7249  {
  double fa;
  __tsu64 bf:48;
};
//SIG(1 STT7249) C1{ FL FL:48}



static void Test_STT7249()
{
  {
    init_simple_test("STT7249");
    static STRUCT_IF_C STT7249 lv;
    check2(sizeof(lv), 16, "sizeof(STT7249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT7249)");
    check_field_offset(lv, fa, 0, "STT7249.fa");
    set_bf_and_test(lv, bf, 8, 0, 48, 1, "STT7249");
    set_bf_and_test(lv, bf, 8, 0, 48, hide_ull(1LL<<47), "STT7249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT7249, STT7249)
//============================================================================


struct  STT810  {
  long double fa;
  unsigned char  :0;
  char fb;
};
//SIG(1 STT810) C1{ FD Fc:0 Fc}



static void Test_STT810()
{
  {
    init_simple_test("STT810");
    static STRUCT_IF_C STT810 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT810)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT810)");
    check_field_offset(lv, fa, 0, "STT810.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT810.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT810, STT810)
//============================================================================


struct  STT820  {
  long double fa;
  unsigned short  :0;
  char fb;
};
//SIG(1 STT820) C1{ FD Fs:0 Fc}



static void Test_STT820()
{
  {
    init_simple_test("STT820");
    static STRUCT_IF_C STT820 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT820)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT820)");
    check_field_offset(lv, fa, 0, "STT820.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT820.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT820, STT820)
//============================================================================


struct  STT830  {
  long double fa;
  unsigned int  :0;
  char fb;
};
//SIG(1 STT830) C1{ FD Fi:0 Fc}



static void Test_STT830()
{
  {
    init_simple_test("STT830");
    static STRUCT_IF_C STT830 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT830)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT830)");
    check_field_offset(lv, fa, 0, "STT830.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT830.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT830, STT830)
//============================================================================


struct  STT840  {
  long double fa;
  __tsu64  :0;
  char fb;
};
//SIG(1 STT840) C1{ FD FL:0 Fc}



static void Test_STT840()
{
  {
    init_simple_test("STT840");
    static STRUCT_IF_C STT840 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT840)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT840)");
    check_field_offset(lv, fa, 0, "STT840.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT840.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT840, STT840)
//============================================================================


struct  STT850  {
  long double fa;
  unsigned char  :3;
  char fb;
};
//SIG(1 STT850) C1{ FD Fc:3 Fc}



static void Test_STT850()
{
  {
    init_simple_test("STT850");
    static STRUCT_IF_C STT850 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT850)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT850)");
    check_field_offset(lv, fa, 0, "STT850.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT850.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT850, STT850)
//============================================================================


struct  STT860  {
  long double fa;
  unsigned short  :3;
  char fb;
};
//SIG(1 STT860) C1{ FD Fs:3 Fc}



static void Test_STT860()
{
  {
    init_simple_test("STT860");
    static STRUCT_IF_C STT860 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT860)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT860)");
    check_field_offset(lv, fa, 0, "STT860.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT860.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT860, STT860)
//============================================================================


struct  STT870  {
  long double fa;
  unsigned int  :3;
  char fb;
};
//SIG(1 STT870) C1{ FD Fi:3 Fc}



static void Test_STT870()
{
  {
    init_simple_test("STT870");
    static STRUCT_IF_C STT870 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT870)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT870)");
    check_field_offset(lv, fa, 0, "STT870.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT870.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT870, STT870)
//============================================================================


struct  STT880  {
  long double fa;
  __tsu64  :3;
  char fb;
};
//SIG(1 STT880) C1{ FD FL:3 Fc}



static void Test_STT880()
{
  {
    init_simple_test("STT880");
    static STRUCT_IF_C STT880 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT880)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT880)");
    check_field_offset(lv, fa, 0, "STT880.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT880.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT880, STT880)
//============================================================================


struct  STT890  {
  long double fa;
  unsigned short  :8;
  char fb;
};
//SIG(1 STT890) C1{ FD Fs:8 Fc}



static void Test_STT890()
{
  {
    init_simple_test("STT890");
    static STRUCT_IF_C STT890 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT890)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT890)");
    check_field_offset(lv, fa, 0, "STT890.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT890.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT890, STT890)
//============================================================================


struct  STT8100  {
  long double fa;
  unsigned int  :8;
  char fb;
};
//SIG(1 STT8100) C1{ FD Fi:8 Fc}



static void Test_STT8100()
{
  {
    init_simple_test("STT8100");
    static STRUCT_IF_C STT8100 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8100)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8100)");
    check_field_offset(lv, fa, 0, "STT8100.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8100, STT8100)
//============================================================================


struct  STT8110  {
  long double fa;
  __tsu64  :8;
  char fb;
};
//SIG(1 STT8110) C1{ FD FL:8 Fc}



static void Test_STT8110()
{
  {
    init_simple_test("STT8110");
    static STRUCT_IF_C STT8110 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8110)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8110)");
    check_field_offset(lv, fa, 0, "STT8110.fa");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8110, STT8110)
//============================================================================


struct  STT8120  {
  long double fa;
  unsigned int  :18;
  char fb;
};
//SIG(1 STT8120) C1{ FD Fi:18 Fc}



static void Test_STT8120()
{
  {
    init_simple_test("STT8120");
    static STRUCT_IF_C STT8120 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8120)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8120)");
    check_field_offset(lv, fa, 0, "STT8120.fa");
    check_field_offset(lv, fb, ABISELECT(19,15), "STT8120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8120, STT8120)
//============================================================================


struct  STT8130  {
  long double fa;
  __tsu64  :18;
  char fb;
};
//SIG(1 STT8130) C1{ FD FL:18 Fc}



static void Test_STT8130()
{
  {
    init_simple_test("STT8130");
    static STRUCT_IF_C STT8130 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8130)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8130)");
    check_field_offset(lv, fa, 0, "STT8130.fa");
    check_field_offset(lv, fb, ABISELECT(19,15), "STT8130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8130, STT8130)
//============================================================================


struct  STT8140  {
  long double fa;
  __tsu64  :48;
  char fb;
};
//SIG(1 STT8140) C1{ FD FL:48 Fc}



static void Test_STT8140()
{
  {
    init_simple_test("STT8140");
    static STRUCT_IF_C STT8140 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8140)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8140)");
    check_field_offset(lv, fa, 0, "STT8140.fa");
    check_field_offset(lv, fb, ABISELECT(22,18), "STT8140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8140, STT8140)
//============================================================================


struct  STT8150  {
  long double fa;
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT8150) C1{ FD Fc:3 Fc}



static void Test_STT8150()
{
  {
    init_simple_test("STT8150");
    static STRUCT_IF_C STT8150 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8150)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8150)");
    check_field_offset(lv, fa, 0, "STT8150.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8150");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8150");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8150, STT8150)
//============================================================================


struct  STT8160  {
  long double fa;
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT8160) C1{ FD Fs:3 Fc}



static void Test_STT8160()
{
  {
    init_simple_test("STT8160");
    static STRUCT_IF_C STT8160 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8160)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8160)");
    check_field_offset(lv, fa, 0, "STT8160.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8160");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8160");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8160, STT8160)
//============================================================================


struct  STT8170  {
  long double fa;
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT8170) C1{ FD Fi:3 Fc}



static void Test_STT8170()
{
  {
    init_simple_test("STT8170");
    static STRUCT_IF_C STT8170 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8170)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8170)");
    check_field_offset(lv, fa, 0, "STT8170.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8170");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8170");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8170, STT8170)
//============================================================================


struct  STT8180  {
  long double fa;
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT8180) C1{ FD FL:3 Fc}



static void Test_STT8180()
{
  {
    init_simple_test("STT8180");
    static STRUCT_IF_C STT8180 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8180)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8180)");
    check_field_offset(lv, fa, 0, "STT8180.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8180");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8180");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8180, STT8180)
//============================================================================


struct  STT8190  {
  long double fa;
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT8190) C1{ FD Fs:8 Fc}



static void Test_STT8190()
{
  {
    init_simple_test("STT8190");
    static STRUCT_IF_C STT8190 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8190)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8190)");
    check_field_offset(lv, fa, 0, "STT8190.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8190");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8190");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8190, STT8190)
//============================================================================


struct  STT8200  {
  long double fa;
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT8200) C1{ FD Fi:8 Fc}



static void Test_STT8200()
{
  {
    init_simple_test("STT8200");
    static STRUCT_IF_C STT8200 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8200)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8200)");
    check_field_offset(lv, fa, 0, "STT8200.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8200");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8200");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8200, STT8200)
//============================================================================


struct  STT8210  {
  long double fa;
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT8210) C1{ FD FL:8 Fc}



static void Test_STT8210()
{
  {
    init_simple_test("STT8210");
    static STRUCT_IF_C STT8210 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8210)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8210)");
    check_field_offset(lv, fa, 0, "STT8210.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8210");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8210");
    check_field_offset(lv, fb, ABISELECT(17,13), "STT8210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8210, STT8210)
//============================================================================


struct  STT8220  {
  long double fa;
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT8220) C1{ FD Fi:18 Fc}



static void Test_STT8220()
{
  {
    init_simple_test("STT8220");
    static STRUCT_IF_C STT8220 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8220)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8220)");
    check_field_offset(lv, fa, 0, "STT8220.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8220");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8220");
    check_field_offset(lv, fb, ABISELECT(19,15), "STT8220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8220, STT8220)
//============================================================================


struct  STT8230  {
  long double fa;
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT8230) C1{ FD FL:18 Fc}



static void Test_STT8230()
{
  {
    init_simple_test("STT8230");
    static STRUCT_IF_C STT8230 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8230)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8230)");
    check_field_offset(lv, fa, 0, "STT8230.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8230");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8230");
    check_field_offset(lv, fb, ABISELECT(19,15), "STT8230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8230, STT8230)
//============================================================================


struct  STT8240  {
  long double fa;
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT8240) C1{ FD FL:48 Fc}



static void Test_STT8240()
{
  {
    init_simple_test("STT8240");
    static STRUCT_IF_C STT8240 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8240)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8240)");
    check_field_offset(lv, fa, 0, "STT8240.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8240");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8240");
    check_field_offset(lv, fb, ABISELECT(22,18), "STT8240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8240, STT8240)
//============================================================================


struct  STT811  {
  long double fa;
  unsigned char  :0;
  short fb;
};
//SIG(1 STT811) C1{ FD Fc:0 Fs}



static void Test_STT811()
{
  {
    init_simple_test("STT811");
    static STRUCT_IF_C STT811 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT811)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT811)");
    check_field_offset(lv, fa, 0, "STT811.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT811.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT811, STT811)
//============================================================================


struct  STT821  {
  long double fa;
  unsigned short  :0;
  short fb;
};
//SIG(1 STT821) C1{ FD Fs:0 Fs}



static void Test_STT821()
{
  {
    init_simple_test("STT821");
    static STRUCT_IF_C STT821 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT821)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT821)");
    check_field_offset(lv, fa, 0, "STT821.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT821.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT821, STT821)
//============================================================================


struct  STT831  {
  long double fa;
  unsigned int  :0;
  short fb;
};
//SIG(1 STT831) C1{ FD Fi:0 Fs}



static void Test_STT831()
{
  {
    init_simple_test("STT831");
    static STRUCT_IF_C STT831 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT831)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT831)");
    check_field_offset(lv, fa, 0, "STT831.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT831.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT831, STT831)
//============================================================================


struct  STT841  {
  long double fa;
  __tsu64  :0;
  short fb;
};
//SIG(1 STT841) C1{ FD FL:0 Fs}



static void Test_STT841()
{
  {
    init_simple_test("STT841");
    static STRUCT_IF_C STT841 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT841)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT841)");
    check_field_offset(lv, fa, 0, "STT841.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT841.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT841, STT841)
//============================================================================


struct  STT851  {
  long double fa;
  unsigned char  :3;
  short fb;
};
//SIG(1 STT851) C1{ FD Fc:3 Fs}



static void Test_STT851()
{
  {
    init_simple_test("STT851");
    static STRUCT_IF_C STT851 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT851)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT851)");
    check_field_offset(lv, fa, 0, "STT851.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT851.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT851, STT851)
//============================================================================


struct  STT861  {
  long double fa;
  unsigned short  :3;
  short fb;
};
//SIG(1 STT861) C1{ FD Fs:3 Fs}



static void Test_STT861()
{
  {
    init_simple_test("STT861");
    static STRUCT_IF_C STT861 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT861)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT861)");
    check_field_offset(lv, fa, 0, "STT861.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT861.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT861, STT861)
//============================================================================


struct  STT871  {
  long double fa;
  unsigned int  :3;
  short fb;
};
//SIG(1 STT871) C1{ FD Fi:3 Fs}



static void Test_STT871()
{
  {
    init_simple_test("STT871");
    static STRUCT_IF_C STT871 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT871)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT871)");
    check_field_offset(lv, fa, 0, "STT871.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT871.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT871, STT871)
//============================================================================


struct  STT881  {
  long double fa;
  __tsu64  :3;
  short fb;
};
//SIG(1 STT881) C1{ FD FL:3 Fs}



static void Test_STT881()
{
  {
    init_simple_test("STT881");
    static STRUCT_IF_C STT881 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT881)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT881)");
    check_field_offset(lv, fa, 0, "STT881.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT881.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT881, STT881)
//============================================================================


struct  STT891  {
  long double fa;
  unsigned short  :8;
  short fb;
};
//SIG(1 STT891) C1{ FD Fs:8 Fs}



static void Test_STT891()
{
  {
    init_simple_test("STT891");
    static STRUCT_IF_C STT891 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT891)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT891)");
    check_field_offset(lv, fa, 0, "STT891.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT891.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT891, STT891)
//============================================================================


struct  STT8101  {
  long double fa;
  unsigned int  :8;
  short fb;
};
//SIG(1 STT8101) C1{ FD Fi:8 Fs}



static void Test_STT8101()
{
  {
    init_simple_test("STT8101");
    static STRUCT_IF_C STT8101 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8101)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8101)");
    check_field_offset(lv, fa, 0, "STT8101.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8101, STT8101)
//============================================================================


struct  STT8111  {
  long double fa;
  __tsu64  :8;
  short fb;
};
//SIG(1 STT8111) C1{ FD FL:8 Fs}



static void Test_STT8111()
{
  {
    init_simple_test("STT8111");
    static STRUCT_IF_C STT8111 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8111)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8111)");
    check_field_offset(lv, fa, 0, "STT8111.fa");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8111, STT8111)
//============================================================================


struct  STT8121  {
  long double fa;
  unsigned int  :18;
  short fb;
};
//SIG(1 STT8121) C1{ FD Fi:18 Fs}



static void Test_STT8121()
{
  {
    init_simple_test("STT8121");
    static STRUCT_IF_C STT8121 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8121)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8121)");
    check_field_offset(lv, fa, 0, "STT8121.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8121, STT8121)
//============================================================================


struct  STT8131  {
  long double fa;
  __tsu64  :18;
  short fb;
};
//SIG(1 STT8131) C1{ FD FL:18 Fs}



static void Test_STT8131()
{
  {
    init_simple_test("STT8131");
    static STRUCT_IF_C STT8131 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8131)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8131)");
    check_field_offset(lv, fa, 0, "STT8131.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8131, STT8131)
//============================================================================


struct  STT8141  {
  long double fa;
  __tsu64  :48;
  short fb;
};
//SIG(1 STT8141) C1{ FD FL:48 Fs}



static void Test_STT8141()
{
  {
    init_simple_test("STT8141");
    static STRUCT_IF_C STT8141 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8141)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8141)");
    check_field_offset(lv, fa, 0, "STT8141.fa");
    check_field_offset(lv, fb, ABISELECT(22,18), "STT8141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8141, STT8141)
//============================================================================


struct  STT8151  {
  long double fa;
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT8151) C1{ FD Fc:3 Fs}



static void Test_STT8151()
{
  {
    init_simple_test("STT8151");
    static STRUCT_IF_C STT8151 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8151)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8151)");
    check_field_offset(lv, fa, 0, "STT8151.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8151");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8151");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8151, STT8151)
//============================================================================


struct  STT8161  {
  long double fa;
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT8161) C1{ FD Fs:3 Fs}



static void Test_STT8161()
{
  {
    init_simple_test("STT8161");
    static STRUCT_IF_C STT8161 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8161)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8161)");
    check_field_offset(lv, fa, 0, "STT8161.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8161");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8161");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8161, STT8161)
//============================================================================


struct  STT8171  {
  long double fa;
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT8171) C1{ FD Fi:3 Fs}



static void Test_STT8171()
{
  {
    init_simple_test("STT8171");
    static STRUCT_IF_C STT8171 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8171)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8171)");
    check_field_offset(lv, fa, 0, "STT8171.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8171");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8171");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8171, STT8171)
//============================================================================


struct  STT8181  {
  long double fa;
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT8181) C1{ FD FL:3 Fs}



static void Test_STT8181()
{
  {
    init_simple_test("STT8181");
    static STRUCT_IF_C STT8181 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8181)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8181)");
    check_field_offset(lv, fa, 0, "STT8181.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8181");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8181");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8181, STT8181)
//============================================================================


struct  STT8191  {
  long double fa;
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT8191) C1{ FD Fs:8 Fs}



static void Test_STT8191()
{
  {
    init_simple_test("STT8191");
    static STRUCT_IF_C STT8191 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8191)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8191)");
    check_field_offset(lv, fa, 0, "STT8191.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8191");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8191");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8191, STT8191)
//============================================================================


struct  STT8201  {
  long double fa;
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT8201) C1{ FD Fi:8 Fs}



static void Test_STT8201()
{
  {
    init_simple_test("STT8201");
    static STRUCT_IF_C STT8201 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8201)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8201)");
    check_field_offset(lv, fa, 0, "STT8201.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8201");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8201");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8201, STT8201)
//============================================================================


struct  STT8211  {
  long double fa;
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT8211) C1{ FD FL:8 Fs}



static void Test_STT8211()
{
  {
    init_simple_test("STT8211");
    static STRUCT_IF_C STT8211 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8211)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8211)");
    check_field_offset(lv, fa, 0, "STT8211.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8211");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8211");
    check_field_offset(lv, fb, ABISELECT(18,14), "STT8211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8211, STT8211)
//============================================================================


struct  STT8221  {
  long double fa;
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT8221) C1{ FD Fi:18 Fs}



static void Test_STT8221()
{
  {
    init_simple_test("STT8221");
    static STRUCT_IF_C STT8221 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8221)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8221)");
    check_field_offset(lv, fa, 0, "STT8221.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8221");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8221");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8221, STT8221)
//============================================================================


struct  STT8231  {
  long double fa;
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT8231) C1{ FD FL:18 Fs}



static void Test_STT8231()
{
  {
    init_simple_test("STT8231");
    static STRUCT_IF_C STT8231 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8231)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8231)");
    check_field_offset(lv, fa, 0, "STT8231.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8231");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8231");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8231, STT8231)
//============================================================================


struct  STT8241  {
  long double fa;
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT8241) C1{ FD FL:48 Fs}



static void Test_STT8241()
{
  {
    init_simple_test("STT8241");
    static STRUCT_IF_C STT8241 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8241)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8241)");
    check_field_offset(lv, fa, 0, "STT8241.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8241");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8241");
    check_field_offset(lv, fb, ABISELECT(22,18), "STT8241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8241, STT8241)
//============================================================================


struct  STT812  {
  long double fa;
  unsigned char  :0;
  int fb;
};
//SIG(1 STT812) C1{ FD Fc:0 Fi}



static void Test_STT812()
{
  {
    init_simple_test("STT812");
    static STRUCT_IF_C STT812 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT812)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT812)");
    check_field_offset(lv, fa, 0, "STT812.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT812.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT812, STT812)
//============================================================================


struct  STT822  {
  long double fa;
  unsigned short  :0;
  int fb;
};
//SIG(1 STT822) C1{ FD Fs:0 Fi}



static void Test_STT822()
{
  {
    init_simple_test("STT822");
    static STRUCT_IF_C STT822 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT822)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT822)");
    check_field_offset(lv, fa, 0, "STT822.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT822.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT822, STT822)
//============================================================================


struct  STT832  {
  long double fa;
  unsigned int  :0;
  int fb;
};
//SIG(1 STT832) C1{ FD Fi:0 Fi}



static void Test_STT832()
{
  {
    init_simple_test("STT832");
    static STRUCT_IF_C STT832 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT832)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT832)");
    check_field_offset(lv, fa, 0, "STT832.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT832.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT832, STT832)
//============================================================================


struct  STT842  {
  long double fa;
  __tsu64  :0;
  int fb;
};
//SIG(1 STT842) C1{ FD FL:0 Fi}



static void Test_STT842()
{
  {
    init_simple_test("STT842");
    static STRUCT_IF_C STT842 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT842)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT842)");
    check_field_offset(lv, fa, 0, "STT842.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT842.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT842, STT842)
//============================================================================


struct  STT852  {
  long double fa;
  unsigned char  :3;
  int fb;
};
//SIG(1 STT852) C1{ FD Fc:3 Fi}



static void Test_STT852()
{
  {
    init_simple_test("STT852");
    static STRUCT_IF_C STT852 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT852)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT852)");
    check_field_offset(lv, fa, 0, "STT852.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT852.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT852, STT852)
//============================================================================


struct  STT862  {
  long double fa;
  unsigned short  :3;
  int fb;
};
//SIG(1 STT862) C1{ FD Fs:3 Fi}



static void Test_STT862()
{
  {
    init_simple_test("STT862");
    static STRUCT_IF_C STT862 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT862)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT862)");
    check_field_offset(lv, fa, 0, "STT862.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT862.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT862, STT862)
//============================================================================


struct  STT872  {
  long double fa;
  unsigned int  :3;
  int fb;
};
//SIG(1 STT872) C1{ FD Fi:3 Fi}



static void Test_STT872()
{
  {
    init_simple_test("STT872");
    static STRUCT_IF_C STT872 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT872)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT872)");
    check_field_offset(lv, fa, 0, "STT872.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT872.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT872, STT872)
//============================================================================


struct  STT882  {
  long double fa;
  __tsu64  :3;
  int fb;
};
//SIG(1 STT882) C1{ FD FL:3 Fi}



static void Test_STT882()
{
  {
    init_simple_test("STT882");
    static STRUCT_IF_C STT882 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT882)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT882)");
    check_field_offset(lv, fa, 0, "STT882.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT882.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT882, STT882)
//============================================================================


struct  STT892  {
  long double fa;
  unsigned short  :8;
  int fb;
};
//SIG(1 STT892) C1{ FD Fs:8 Fi}



static void Test_STT892()
{
  {
    init_simple_test("STT892");
    static STRUCT_IF_C STT892 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT892)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT892)");
    check_field_offset(lv, fa, 0, "STT892.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT892.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT892, STT892)
//============================================================================


struct  STT8102  {
  long double fa;
  unsigned int  :8;
  int fb;
};
//SIG(1 STT8102) C1{ FD Fi:8 Fi}



static void Test_STT8102()
{
  {
    init_simple_test("STT8102");
    static STRUCT_IF_C STT8102 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8102)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8102)");
    check_field_offset(lv, fa, 0, "STT8102.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8102, STT8102)
//============================================================================


struct  STT8112  {
  long double fa;
  __tsu64  :8;
  int fb;
};
//SIG(1 STT8112) C1{ FD FL:8 Fi}



static void Test_STT8112()
{
  {
    init_simple_test("STT8112");
    static STRUCT_IF_C STT8112 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8112)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8112)");
    check_field_offset(lv, fa, 0, "STT8112.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8112, STT8112)
//============================================================================


struct  STT8122  {
  long double fa;
  unsigned int  :18;
  int fb;
};
//SIG(1 STT8122) C1{ FD Fi:18 Fi}



static void Test_STT8122()
{
  {
    init_simple_test("STT8122");
    static STRUCT_IF_C STT8122 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8122)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8122)");
    check_field_offset(lv, fa, 0, "STT8122.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8122, STT8122)
//============================================================================


struct  STT8132  {
  long double fa;
  __tsu64  :18;
  int fb;
};
//SIG(1 STT8132) C1{ FD FL:18 Fi}



static void Test_STT8132()
{
  {
    init_simple_test("STT8132");
    static STRUCT_IF_C STT8132 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8132)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8132)");
    check_field_offset(lv, fa, 0, "STT8132.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8132, STT8132)
//============================================================================


struct  STT8142  {
  long double fa;
  __tsu64  :48;
  int fb;
};
//SIG(1 STT8142) C1{ FD FL:48 Fi}



static void Test_STT8142()
{
  {
    init_simple_test("STT8142");
    static STRUCT_IF_C STT8142 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8142)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8142)");
    check_field_offset(lv, fa, 0, "STT8142.fa");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8142, STT8142)
//============================================================================


struct  STT8152  {
  long double fa;
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT8152) C1{ FD Fc:3 Fi}



static void Test_STT8152()
{
  {
    init_simple_test("STT8152");
    static STRUCT_IF_C STT8152 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8152)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8152)");
    check_field_offset(lv, fa, 0, "STT8152.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8152");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8152");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8152, STT8152)
//============================================================================


struct  STT8162  {
  long double fa;
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT8162) C1{ FD Fs:3 Fi}



static void Test_STT8162()
{
  {
    init_simple_test("STT8162");
    static STRUCT_IF_C STT8162 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8162)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8162)");
    check_field_offset(lv, fa, 0, "STT8162.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8162");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8162");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8162, STT8162)
//============================================================================


struct  STT8172  {
  long double fa;
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT8172) C1{ FD Fi:3 Fi}



static void Test_STT8172()
{
  {
    init_simple_test("STT8172");
    static STRUCT_IF_C STT8172 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8172)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8172)");
    check_field_offset(lv, fa, 0, "STT8172.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8172");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8172");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8172, STT8172)
//============================================================================


struct  STT8182  {
  long double fa;
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT8182) C1{ FD FL:3 Fi}



static void Test_STT8182()
{
  {
    init_simple_test("STT8182");
    static STRUCT_IF_C STT8182 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8182)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8182)");
    check_field_offset(lv, fa, 0, "STT8182.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8182");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8182");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8182, STT8182)
//============================================================================


struct  STT8192  {
  long double fa;
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT8192) C1{ FD Fs:8 Fi}



static void Test_STT8192()
{
  {
    init_simple_test("STT8192");
    static STRUCT_IF_C STT8192 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8192)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8192)");
    check_field_offset(lv, fa, 0, "STT8192.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8192");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8192");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8192, STT8192)
//============================================================================


struct  STT8202  {
  long double fa;
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT8202) C1{ FD Fi:8 Fi}



static void Test_STT8202()
{
  {
    init_simple_test("STT8202");
    static STRUCT_IF_C STT8202 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8202)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8202)");
    check_field_offset(lv, fa, 0, "STT8202.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8202");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8202");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8202, STT8202)
//============================================================================


struct  STT8212  {
  long double fa;
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT8212) C1{ FD FL:8 Fi}



static void Test_STT8212()
{
  {
    init_simple_test("STT8212");
    static STRUCT_IF_C STT8212 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8212)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8212)");
    check_field_offset(lv, fa, 0, "STT8212.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8212");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8212");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8212, STT8212)
//============================================================================


struct  STT8222  {
  long double fa;
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT8222) C1{ FD Fi:18 Fi}



static void Test_STT8222()
{
  {
    init_simple_test("STT8222");
    static STRUCT_IF_C STT8222 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8222)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8222)");
    check_field_offset(lv, fa, 0, "STT8222.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8222");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8222");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8222, STT8222)
//============================================================================


struct  STT8232  {
  long double fa;
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT8232) C1{ FD FL:18 Fi}



static void Test_STT8232()
{
  {
    init_simple_test("STT8232");
    static STRUCT_IF_C STT8232 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8232)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8232)");
    check_field_offset(lv, fa, 0, "STT8232.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8232");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8232");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8232, STT8232)
//============================================================================


struct  STT8242  {
  long double fa;
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT8242) C1{ FD FL:48 Fi}



static void Test_STT8242()
{
  {
    init_simple_test("STT8242");
    static STRUCT_IF_C STT8242 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8242)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8242)");
    check_field_offset(lv, fa, 0, "STT8242.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8242");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8242");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8242, STT8242)
//============================================================================


struct  STT813  {
  long double fa;
  unsigned char  :0;
  long fb;
};
//SIG(1 STT813) C1{ FD Fc:0 Fl}



static void Test_STT813()
{
  {
    init_simple_test("STT813");
    static STRUCT_IF_C STT813 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT813)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT813)");
    check_field_offset(lv, fa, 0, "STT813.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT813.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT813, STT813)
//============================================================================


struct  STT823  {
  long double fa;
  unsigned short  :0;
  long fb;
};
//SIG(1 STT823) C1{ FD Fs:0 Fl}



static void Test_STT823()
{
  {
    init_simple_test("STT823");
    static STRUCT_IF_C STT823 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT823)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT823)");
    check_field_offset(lv, fa, 0, "STT823.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT823.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT823, STT823)
//============================================================================


struct  STT833  {
  long double fa;
  unsigned int  :0;
  long fb;
};
//SIG(1 STT833) C1{ FD Fi:0 Fl}



static void Test_STT833()
{
  {
    init_simple_test("STT833");
    static STRUCT_IF_C STT833 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT833)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT833)");
    check_field_offset(lv, fa, 0, "STT833.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT833.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT833, STT833)
//============================================================================


struct  STT843  {
  long double fa;
  __tsu64  :0;
  long fb;
};
//SIG(1 STT843) C1{ FD FL:0 Fl}



static void Test_STT843()
{
  {
    init_simple_test("STT843");
    static STRUCT_IF_C STT843 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT843)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT843)");
    check_field_offset(lv, fa, 0, "STT843.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT843.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT843, STT843)
//============================================================================


struct  STT853  {
  long double fa;
  unsigned char  :3;
  long fb;
};
//SIG(1 STT853) C1{ FD Fc:3 Fl}



static void Test_STT853()
{
  {
    init_simple_test("STT853");
    static STRUCT_IF_C STT853 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT853)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT853)");
    check_field_offset(lv, fa, 0, "STT853.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT853.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT853, STT853)
//============================================================================


struct  STT863  {
  long double fa;
  unsigned short  :3;
  long fb;
};
//SIG(1 STT863) C1{ FD Fs:3 Fl}



static void Test_STT863()
{
  {
    init_simple_test("STT863");
    static STRUCT_IF_C STT863 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT863)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT863)");
    check_field_offset(lv, fa, 0, "STT863.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT863.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT863, STT863)
//============================================================================


struct  STT873  {
  long double fa;
  unsigned int  :3;
  long fb;
};
//SIG(1 STT873) C1{ FD Fi:3 Fl}



static void Test_STT873()
{
  {
    init_simple_test("STT873");
    static STRUCT_IF_C STT873 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT873)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT873)");
    check_field_offset(lv, fa, 0, "STT873.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT873.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT873, STT873)
//============================================================================


struct  STT883  {
  long double fa;
  __tsu64  :3;
  long fb;
};
//SIG(1 STT883) C1{ FD FL:3 Fl}



static void Test_STT883()
{
  {
    init_simple_test("STT883");
    static STRUCT_IF_C STT883 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT883)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT883)");
    check_field_offset(lv, fa, 0, "STT883.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT883.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT883, STT883)
//============================================================================


struct  STT893  {
  long double fa;
  unsigned short  :8;
  long fb;
};
//SIG(1 STT893) C1{ FD Fs:8 Fl}



static void Test_STT893()
{
  {
    init_simple_test("STT893");
    static STRUCT_IF_C STT893 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT893)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT893)");
    check_field_offset(lv, fa, 0, "STT893.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT893.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT893, STT893)
//============================================================================


struct  STT8103  {
  long double fa;
  unsigned int  :8;
  long fb;
};
//SIG(1 STT8103) C1{ FD Fi:8 Fl}



static void Test_STT8103()
{
  {
    init_simple_test("STT8103");
    static STRUCT_IF_C STT8103 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8103)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8103)");
    check_field_offset(lv, fa, 0, "STT8103.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8103, STT8103)
//============================================================================


struct  STT8113  {
  long double fa;
  __tsu64  :8;
  long fb;
};
//SIG(1 STT8113) C1{ FD FL:8 Fl}



static void Test_STT8113()
{
  {
    init_simple_test("STT8113");
    static STRUCT_IF_C STT8113 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8113)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8113)");
    check_field_offset(lv, fa, 0, "STT8113.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8113, STT8113)
//============================================================================


struct  STT8123  {
  long double fa;
  unsigned int  :18;
  long fb;
};
//SIG(1 STT8123) C1{ FD Fi:18 Fl}



static void Test_STT8123()
{
  {
    init_simple_test("STT8123");
    static STRUCT_IF_C STT8123 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8123)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8123)");
    check_field_offset(lv, fa, 0, "STT8123.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8123, STT8123)
//============================================================================


struct  STT8133  {
  long double fa;
  __tsu64  :18;
  long fb;
};
//SIG(1 STT8133) C1{ FD FL:18 Fl}



static void Test_STT8133()
{
  {
    init_simple_test("STT8133");
    static STRUCT_IF_C STT8133 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8133)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8133)");
    check_field_offset(lv, fa, 0, "STT8133.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8133, STT8133)
//============================================================================


struct  STT8143  {
  long double fa;
  __tsu64  :48;
  long fb;
};
//SIG(1 STT8143) C1{ FD FL:48 Fl}



static void Test_STT8143()
{
  {
    init_simple_test("STT8143");
    static STRUCT_IF_C STT8143 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8143)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8143)");
    check_field_offset(lv, fa, 0, "STT8143.fa");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8143, STT8143)
//============================================================================


struct  STT8153  {
  long double fa;
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT8153) C1{ FD Fc:3 Fl}



static void Test_STT8153()
{
  {
    init_simple_test("STT8153");
    static STRUCT_IF_C STT8153 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8153)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8153)");
    check_field_offset(lv, fa, 0, "STT8153.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8153");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8153");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8153, STT8153)
//============================================================================


struct  STT8163  {
  long double fa;
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT8163) C1{ FD Fs:3 Fl}



static void Test_STT8163()
{
  {
    init_simple_test("STT8163");
    static STRUCT_IF_C STT8163 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8163)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8163)");
    check_field_offset(lv, fa, 0, "STT8163.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8163");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8163");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8163, STT8163)
//============================================================================


struct  STT8173  {
  long double fa;
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT8173) C1{ FD Fi:3 Fl}



static void Test_STT8173()
{
  {
    init_simple_test("STT8173");
    static STRUCT_IF_C STT8173 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8173)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8173)");
    check_field_offset(lv, fa, 0, "STT8173.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8173");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8173");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8173, STT8173)
//============================================================================


struct  STT8183  {
  long double fa;
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT8183) C1{ FD FL:3 Fl}



static void Test_STT8183()
{
  {
    init_simple_test("STT8183");
    static STRUCT_IF_C STT8183 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8183)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8183)");
    check_field_offset(lv, fa, 0, "STT8183.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8183");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8183");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8183, STT8183)
//============================================================================


struct  STT8193  {
  long double fa;
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT8193) C1{ FD Fs:8 Fl}



static void Test_STT8193()
{
  {
    init_simple_test("STT8193");
    static STRUCT_IF_C STT8193 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8193)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8193)");
    check_field_offset(lv, fa, 0, "STT8193.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8193");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8193");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8193, STT8193)
//============================================================================


struct  STT8203  {
  long double fa;
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT8203) C1{ FD Fi:8 Fl}



static void Test_STT8203()
{
  {
    init_simple_test("STT8203");
    static STRUCT_IF_C STT8203 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8203)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8203)");
    check_field_offset(lv, fa, 0, "STT8203.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8203");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8203");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8203, STT8203)
//============================================================================


struct  STT8213  {
  long double fa;
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT8213) C1{ FD FL:8 Fl}



static void Test_STT8213()
{
  {
    init_simple_test("STT8213");
    static STRUCT_IF_C STT8213 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8213)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8213)");
    check_field_offset(lv, fa, 0, "STT8213.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8213");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8213");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8213, STT8213)
//============================================================================


struct  STT8223  {
  long double fa;
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT8223) C1{ FD Fi:18 Fl}



static void Test_STT8223()
{
  {
    init_simple_test("STT8223");
    static STRUCT_IF_C STT8223 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8223)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8223)");
    check_field_offset(lv, fa, 0, "STT8223.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8223");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8223");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8223, STT8223)
//============================================================================


struct  STT8233  {
  long double fa;
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT8233) C1{ FD FL:18 Fl}



static void Test_STT8233()
{
  {
    init_simple_test("STT8233");
    static STRUCT_IF_C STT8233 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8233)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8233)");
    check_field_offset(lv, fa, 0, "STT8233.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8233");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8233");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8233, STT8233)
//============================================================================


struct  STT8243  {
  long double fa;
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT8243) C1{ FD FL:48 Fl}



static void Test_STT8243()
{
  {
    init_simple_test("STT8243");
    static STRUCT_IF_C STT8243 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8243)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8243)");
    check_field_offset(lv, fa, 0, "STT8243.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8243");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8243");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8243, STT8243)
//============================================================================


struct  STT814  {
  long double fa;
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT814) C1{ FD Fc:0 FL}



static void Test_STT814()
{
  {
    init_simple_test("STT814");
    static STRUCT_IF_C STT814 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT814)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT814)");
    check_field_offset(lv, fa, 0, "STT814.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT814.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT814, STT814)
//============================================================================


struct  STT824  {
  long double fa;
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT824) C1{ FD Fs:0 FL}



static void Test_STT824()
{
  {
    init_simple_test("STT824");
    static STRUCT_IF_C STT824 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT824)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT824)");
    check_field_offset(lv, fa, 0, "STT824.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT824.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT824, STT824)
//============================================================================


struct  STT834  {
  long double fa;
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT834) C1{ FD Fi:0 FL}



static void Test_STT834()
{
  {
    init_simple_test("STT834");
    static STRUCT_IF_C STT834 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT834)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT834)");
    check_field_offset(lv, fa, 0, "STT834.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT834.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT834, STT834)
//============================================================================


struct  STT844  {
  long double fa;
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT844) C1{ FD FL:0 FL}



static void Test_STT844()
{
  {
    init_simple_test("STT844");
    static STRUCT_IF_C STT844 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT844)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT844)");
    check_field_offset(lv, fa, 0, "STT844.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT844.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT844, STT844)
//============================================================================


struct  STT854  {
  long double fa;
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT854) C1{ FD Fc:3 FL}



static void Test_STT854()
{
  {
    init_simple_test("STT854");
    static STRUCT_IF_C STT854 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT854)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT854)");
    check_field_offset(lv, fa, 0, "STT854.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT854.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT854, STT854)
//============================================================================


struct  STT864  {
  long double fa;
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT864) C1{ FD Fs:3 FL}



static void Test_STT864()
{
  {
    init_simple_test("STT864");
    static STRUCT_IF_C STT864 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT864)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT864)");
    check_field_offset(lv, fa, 0, "STT864.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT864.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT864, STT864)
//============================================================================


struct  STT874  {
  long double fa;
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT874) C1{ FD Fi:3 FL}



static void Test_STT874()
{
  {
    init_simple_test("STT874");
    static STRUCT_IF_C STT874 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT874)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT874)");
    check_field_offset(lv, fa, 0, "STT874.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT874.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT874, STT874)
//============================================================================


struct  STT884  {
  long double fa;
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT884) C1{ FD FL:3 FL}



static void Test_STT884()
{
  {
    init_simple_test("STT884");
    static STRUCT_IF_C STT884 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT884)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT884)");
    check_field_offset(lv, fa, 0, "STT884.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT884.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT884, STT884)
//============================================================================


struct  STT894  {
  long double fa;
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT894) C1{ FD Fs:8 FL}



static void Test_STT894()
{
  {
    init_simple_test("STT894");
    static STRUCT_IF_C STT894 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT894)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT894)");
    check_field_offset(lv, fa, 0, "STT894.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT894.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT894, STT894)
//============================================================================


struct  STT8104  {
  long double fa;
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT8104) C1{ FD Fi:8 FL}



static void Test_STT8104()
{
  {
    init_simple_test("STT8104");
    static STRUCT_IF_C STT8104 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8104)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8104)");
    check_field_offset(lv, fa, 0, "STT8104.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8104, STT8104)
//============================================================================


struct  STT8114  {
  long double fa;
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT8114) C1{ FD FL:8 FL}



static void Test_STT8114()
{
  {
    init_simple_test("STT8114");
    static STRUCT_IF_C STT8114 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8114)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8114)");
    check_field_offset(lv, fa, 0, "STT8114.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8114, STT8114)
//============================================================================


struct  STT8124  {
  long double fa;
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT8124) C1{ FD Fi:18 FL}



static void Test_STT8124()
{
  {
    init_simple_test("STT8124");
    static STRUCT_IF_C STT8124 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8124)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8124)");
    check_field_offset(lv, fa, 0, "STT8124.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8124, STT8124)
//============================================================================


struct  STT8134  {
  long double fa;
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT8134) C1{ FD FL:18 FL}



static void Test_STT8134()
{
  {
    init_simple_test("STT8134");
    static STRUCT_IF_C STT8134 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8134)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8134)");
    check_field_offset(lv, fa, 0, "STT8134.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8134, STT8134)
//============================================================================


struct  STT8144  {
  long double fa;
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT8144) C1{ FD FL:48 FL}



static void Test_STT8144()
{
  {
    init_simple_test("STT8144");
    static STRUCT_IF_C STT8144 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT8144)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8144)");
    check_field_offset(lv, fa, 0, "STT8144.fa");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8144, STT8144)
//============================================================================


struct  STT8154  {
  long double fa;
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT8154) C1{ FD Fc:3 FL}



static void Test_STT8154()
{
  {
    init_simple_test("STT8154");
    static STRUCT_IF_C STT8154 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8154)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8154)");
    check_field_offset(lv, fa, 0, "STT8154.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8154");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8154");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8154, STT8154)
//============================================================================


struct  STT8164  {
  long double fa;
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT8164) C1{ FD Fs:3 FL}



static void Test_STT8164()
{
  {
    init_simple_test("STT8164");
    static STRUCT_IF_C STT8164 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8164)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8164)");
    check_field_offset(lv, fa, 0, "STT8164.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8164");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8164");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8164, STT8164)
//============================================================================


struct  STT8174  {
  long double fa;
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT8174) C1{ FD Fi:3 FL}



static void Test_STT8174()
{
  {
    init_simple_test("STT8174");
    static STRUCT_IF_C STT8174 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8174)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8174)");
    check_field_offset(lv, fa, 0, "STT8174.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8174");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8174");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8174, STT8174)
//============================================================================


struct  STT8184  {
  long double fa;
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT8184) C1{ FD FL:3 FL}



static void Test_STT8184()
{
  {
    init_simple_test("STT8184");
    static STRUCT_IF_C STT8184 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8184)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8184)");
    check_field_offset(lv, fa, 0, "STT8184.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8184");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8184");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8184, STT8184)
//============================================================================


struct  STT8194  {
  long double fa;
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT8194) C1{ FD Fs:8 FL}



static void Test_STT8194()
{
  {
    init_simple_test("STT8194");
    static STRUCT_IF_C STT8194 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8194)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8194)");
    check_field_offset(lv, fa, 0, "STT8194.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8194");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8194");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8194, STT8194)
//============================================================================


struct  STT8204  {
  long double fa;
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT8204) C1{ FD Fi:8 FL}



static void Test_STT8204()
{
  {
    init_simple_test("STT8204");
    static STRUCT_IF_C STT8204 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8204)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8204)");
    check_field_offset(lv, fa, 0, "STT8204.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8204");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8204");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8204, STT8204)
//============================================================================


struct  STT8214  {
  long double fa;
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT8214) C1{ FD FL:8 FL}



static void Test_STT8214()
{
  {
    init_simple_test("STT8214");
    static STRUCT_IF_C STT8214 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8214)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8214)");
    check_field_offset(lv, fa, 0, "STT8214.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8214");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8214");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8214, STT8214)
//============================================================================


struct  STT8224  {
  long double fa;
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT8224) C1{ FD Fi:18 FL}



static void Test_STT8224()
{
  {
    init_simple_test("STT8224");
    static STRUCT_IF_C STT8224 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8224)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8224)");
    check_field_offset(lv, fa, 0, "STT8224.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8224");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8224");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8224, STT8224)
//============================================================================


struct  STT8234  {
  long double fa;
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT8234) C1{ FD FL:18 FL}



static void Test_STT8234()
{
  {
    init_simple_test("STT8234");
    static STRUCT_IF_C STT8234 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8234)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8234)");
    check_field_offset(lv, fa, 0, "STT8234.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8234");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8234");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8234, STT8234)
//============================================================================


struct  STT8244  {
  long double fa;
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT8244) C1{ FD FL:48 FL}



static void Test_STT8244()
{
  {
    init_simple_test("STT8244");
    static STRUCT_IF_C STT8244 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT8244)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8244)");
    check_field_offset(lv, fa, 0, "STT8244.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8244");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8244");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8244, STT8244)
//============================================================================


struct  STT815  {
  long double fa;
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT815) C1{ FD Fc:0 Fp}



static void Test_STT815()
{
  {
    init_simple_test("STT815");
    static STRUCT_IF_C STT815 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT815)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT815)");
    check_field_offset(lv, fa, 0, "STT815.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT815.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT815, STT815)
//============================================================================


struct  STT825  {
  long double fa;
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT825) C1{ FD Fs:0 Fp}



static void Test_STT825()
{
  {
    init_simple_test("STT825");
    static STRUCT_IF_C STT825 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT825)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT825)");
    check_field_offset(lv, fa, 0, "STT825.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT825.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT825, STT825)
//============================================================================


struct  STT835  {
  long double fa;
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT835) C1{ FD Fi:0 Fp}



static void Test_STT835()
{
  {
    init_simple_test("STT835");
    static STRUCT_IF_C STT835 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT835)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT835)");
    check_field_offset(lv, fa, 0, "STT835.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT835.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT835, STT835)
//============================================================================


struct  STT845  {
  long double fa;
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT845) C1{ FD FL:0 Fp}



static void Test_STT845()
{
  {
    init_simple_test("STT845");
    static STRUCT_IF_C STT845 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT845)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT845)");
    check_field_offset(lv, fa, 0, "STT845.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT845.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT845, STT845)
//============================================================================


struct  STT855  {
  long double fa;
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT855) C1{ FD Fc:3 Fp}



static void Test_STT855()
{
  {
    init_simple_test("STT855");
    static STRUCT_IF_C STT855 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT855)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT855)");
    check_field_offset(lv, fa, 0, "STT855.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT855.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT855, STT855)
//============================================================================


struct  STT865  {
  long double fa;
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT865) C1{ FD Fs:3 Fp}



static void Test_STT865()
{
  {
    init_simple_test("STT865");
    static STRUCT_IF_C STT865 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT865)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT865)");
    check_field_offset(lv, fa, 0, "STT865.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT865.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT865, STT865)
//============================================================================


struct  STT875  {
  long double fa;
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT875) C1{ FD Fi:3 Fp}



static void Test_STT875()
{
  {
    init_simple_test("STT875");
    static STRUCT_IF_C STT875 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT875)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT875)");
    check_field_offset(lv, fa, 0, "STT875.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT875.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT875, STT875)
//============================================================================


struct  STT885  {
  long double fa;
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT885) C1{ FD FL:3 Fp}



static void Test_STT885()
{
  {
    init_simple_test("STT885");
    static STRUCT_IF_C STT885 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT885)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT885)");
    check_field_offset(lv, fa, 0, "STT885.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT885.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT885, STT885)
//============================================================================


struct  STT895  {
  long double fa;
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT895) C1{ FD Fs:8 Fp}



static void Test_STT895()
{
  {
    init_simple_test("STT895");
    static STRUCT_IF_C STT895 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT895)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT895)");
    check_field_offset(lv, fa, 0, "STT895.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT895.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT895, STT895)
//============================================================================


struct  STT8105  {
  long double fa;
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT8105) C1{ FD Fi:8 Fp}



static void Test_STT8105()
{
  {
    init_simple_test("STT8105");
    static STRUCT_IF_C STT8105 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8105)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8105)");
    check_field_offset(lv, fa, 0, "STT8105.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8105, STT8105)
//============================================================================


struct  STT8115  {
  long double fa;
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT8115) C1{ FD FL:8 Fp}



static void Test_STT8115()
{
  {
    init_simple_test("STT8115");
    static STRUCT_IF_C STT8115 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8115)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8115)");
    check_field_offset(lv, fa, 0, "STT8115.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8115, STT8115)
//============================================================================


struct  STT8125  {
  long double fa;
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT8125) C1{ FD Fi:18 Fp}



static void Test_STT8125()
{
  {
    init_simple_test("STT8125");
    static STRUCT_IF_C STT8125 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8125)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8125)");
    check_field_offset(lv, fa, 0, "STT8125.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8125, STT8125)
//============================================================================


struct  STT8135  {
  long double fa;
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT8135) C1{ FD FL:18 Fp}



static void Test_STT8135()
{
  {
    init_simple_test("STT8135");
    static STRUCT_IF_C STT8135 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8135)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8135)");
    check_field_offset(lv, fa, 0, "STT8135.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8135, STT8135)
//============================================================================


struct  STT8145  {
  long double fa;
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT8145) C1{ FD FL:48 Fp}



static void Test_STT8145()
{
  {
    init_simple_test("STT8145");
    static STRUCT_IF_C STT8145 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8145)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8145)");
    check_field_offset(lv, fa, 0, "STT8145.fa");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8145, STT8145)
//============================================================================


struct  STT8155  {
  long double fa;
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT8155) C1{ FD Fc:3 Fp}



static void Test_STT8155()
{
  {
    init_simple_test("STT8155");
    static STRUCT_IF_C STT8155 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8155)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8155)");
    check_field_offset(lv, fa, 0, "STT8155.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8155");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8155");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8155, STT8155)
//============================================================================


struct  STT8165  {
  long double fa;
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT8165) C1{ FD Fs:3 Fp}



static void Test_STT8165()
{
  {
    init_simple_test("STT8165");
    static STRUCT_IF_C STT8165 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8165)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8165)");
    check_field_offset(lv, fa, 0, "STT8165.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8165");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8165");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8165, STT8165)
//============================================================================


struct  STT8175  {
  long double fa;
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT8175) C1{ FD Fi:3 Fp}



static void Test_STT8175()
{
  {
    init_simple_test("STT8175");
    static STRUCT_IF_C STT8175 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8175)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8175)");
    check_field_offset(lv, fa, 0, "STT8175.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8175");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8175");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8175, STT8175)
//============================================================================


struct  STT8185  {
  long double fa;
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT8185) C1{ FD FL:3 Fp}



static void Test_STT8185()
{
  {
    init_simple_test("STT8185");
    static STRUCT_IF_C STT8185 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8185)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8185)");
    check_field_offset(lv, fa, 0, "STT8185.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8185");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8185");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8185, STT8185)
//============================================================================


struct  STT8195  {
  long double fa;
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT8195) C1{ FD Fs:8 Fp}



static void Test_STT8195()
{
  {
    init_simple_test("STT8195");
    static STRUCT_IF_C STT8195 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8195)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8195)");
    check_field_offset(lv, fa, 0, "STT8195.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8195");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8195");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8195, STT8195)
//============================================================================


struct  STT8205  {
  long double fa;
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT8205) C1{ FD Fi:8 Fp}



static void Test_STT8205()
{
  {
    init_simple_test("STT8205");
    static STRUCT_IF_C STT8205 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8205)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8205)");
    check_field_offset(lv, fa, 0, "STT8205.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8205");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8205");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8205, STT8205)
//============================================================================


struct  STT8215  {
  long double fa;
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT8215) C1{ FD FL:8 Fp}



static void Test_STT8215()
{
  {
    init_simple_test("STT8215");
    static STRUCT_IF_C STT8215 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8215)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8215)");
    check_field_offset(lv, fa, 0, "STT8215.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8215");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8215");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8215, STT8215)
//============================================================================


struct  STT8225  {
  long double fa;
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT8225) C1{ FD Fi:18 Fp}



static void Test_STT8225()
{
  {
    init_simple_test("STT8225");
    static STRUCT_IF_C STT8225 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8225)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8225)");
    check_field_offset(lv, fa, 0, "STT8225.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8225");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8225");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8225, STT8225)
//============================================================================


struct  STT8235  {
  long double fa;
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT8235) C1{ FD FL:18 Fp}



static void Test_STT8235()
{
  {
    init_simple_test("STT8235");
    static STRUCT_IF_C STT8235 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8235)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8235)");
    check_field_offset(lv, fa, 0, "STT8235.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8235");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8235");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8235, STT8235)
//============================================================================


struct  STT8245  {
  long double fa;
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT8245) C1{ FD FL:48 Fp}



static void Test_STT8245()
{
  {
    init_simple_test("STT8245");
    static STRUCT_IF_C STT8245 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8245)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8245)");
    check_field_offset(lv, fa, 0, "STT8245.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8245");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8245");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8245, STT8245)
//============================================================================


struct  STT816  {
  long double fa;
  unsigned char  :0;
  float fb;
};
//SIG(1 STT816) C1{ FD Fc:0 Fi}



static void Test_STT816()
{
  {
    init_simple_test("STT816");
    static STRUCT_IF_C STT816 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT816)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT816)");
    check_field_offset(lv, fa, 0, "STT816.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT816.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT816, STT816)
//============================================================================


struct  STT826  {
  long double fa;
  unsigned short  :0;
  float fb;
};
//SIG(1 STT826) C1{ FD Fs:0 Fi}



static void Test_STT826()
{
  {
    init_simple_test("STT826");
    static STRUCT_IF_C STT826 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT826)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT826)");
    check_field_offset(lv, fa, 0, "STT826.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT826.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT826, STT826)
//============================================================================


struct  STT836  {
  long double fa;
  unsigned int  :0;
  float fb;
};
//SIG(1 STT836) C1{ FD Fi:0 Fi}



static void Test_STT836()
{
  {
    init_simple_test("STT836");
    static STRUCT_IF_C STT836 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT836)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT836)");
    check_field_offset(lv, fa, 0, "STT836.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT836.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT836, STT836)
//============================================================================


struct  STT846  {
  long double fa;
  __tsu64  :0;
  float fb;
};
//SIG(1 STT846) C1{ FD FL:0 Fi}



static void Test_STT846()
{
  {
    init_simple_test("STT846");
    static STRUCT_IF_C STT846 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT846)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT846)");
    check_field_offset(lv, fa, 0, "STT846.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT846.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT846, STT846)
//============================================================================


struct  STT856  {
  long double fa;
  unsigned char  :3;
  float fb;
};
//SIG(1 STT856) C1{ FD Fc:3 Fi}



static void Test_STT856()
{
  {
    init_simple_test("STT856");
    static STRUCT_IF_C STT856 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT856)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT856)");
    check_field_offset(lv, fa, 0, "STT856.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT856.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT856, STT856)
//============================================================================


struct  STT866  {
  long double fa;
  unsigned short  :3;
  float fb;
};
//SIG(1 STT866) C1{ FD Fs:3 Fi}



static void Test_STT866()
{
  {
    init_simple_test("STT866");
    static STRUCT_IF_C STT866 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT866)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT866)");
    check_field_offset(lv, fa, 0, "STT866.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT866.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT866, STT866)
//============================================================================


struct  STT876  {
  long double fa;
  unsigned int  :3;
  float fb;
};
//SIG(1 STT876) C1{ FD Fi:3 Fi}



static void Test_STT876()
{
  {
    init_simple_test("STT876");
    static STRUCT_IF_C STT876 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT876)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT876)");
    check_field_offset(lv, fa, 0, "STT876.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT876.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT876, STT876)
//============================================================================


struct  STT886  {
  long double fa;
  __tsu64  :3;
  float fb;
};
//SIG(1 STT886) C1{ FD FL:3 Fi}



static void Test_STT886()
{
  {
    init_simple_test("STT886");
    static STRUCT_IF_C STT886 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT886)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT886)");
    check_field_offset(lv, fa, 0, "STT886.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT886.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT886, STT886)
//============================================================================


struct  STT896  {
  long double fa;
  unsigned short  :8;
  float fb;
};
//SIG(1 STT896) C1{ FD Fs:8 Fi}



static void Test_STT896()
{
  {
    init_simple_test("STT896");
    static STRUCT_IF_C STT896 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT896)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT896)");
    check_field_offset(lv, fa, 0, "STT896.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT896.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT896, STT896)
//============================================================================


struct  STT8106  {
  long double fa;
  unsigned int  :8;
  float fb;
};
//SIG(1 STT8106) C1{ FD Fi:8 Fi}



static void Test_STT8106()
{
  {
    init_simple_test("STT8106");
    static STRUCT_IF_C STT8106 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8106)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8106)");
    check_field_offset(lv, fa, 0, "STT8106.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8106, STT8106)
//============================================================================


struct  STT8116  {
  long double fa;
  __tsu64  :8;
  float fb;
};
//SIG(1 STT8116) C1{ FD FL:8 Fi}



static void Test_STT8116()
{
  {
    init_simple_test("STT8116");
    static STRUCT_IF_C STT8116 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8116)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8116)");
    check_field_offset(lv, fa, 0, "STT8116.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8116, STT8116)
//============================================================================


struct  STT8126  {
  long double fa;
  unsigned int  :18;
  float fb;
};
//SIG(1 STT8126) C1{ FD Fi:18 Fi}



static void Test_STT8126()
{
  {
    init_simple_test("STT8126");
    static STRUCT_IF_C STT8126 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8126)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8126)");
    check_field_offset(lv, fa, 0, "STT8126.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8126, STT8126)
//============================================================================


struct  STT8136  {
  long double fa;
  __tsu64  :18;
  float fb;
};
//SIG(1 STT8136) C1{ FD FL:18 Fi}



static void Test_STT8136()
{
  {
    init_simple_test("STT8136");
    static STRUCT_IF_C STT8136 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8136)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8136)");
    check_field_offset(lv, fa, 0, "STT8136.fa");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8136, STT8136)
//============================================================================


struct  STT8146  {
  long double fa;
  __tsu64  :48;
  float fb;
};
//SIG(1 STT8146) C1{ FD FL:48 Fi}



static void Test_STT8146()
{
  {
    init_simple_test("STT8146");
    static STRUCT_IF_C STT8146 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8146)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8146)");
    check_field_offset(lv, fa, 0, "STT8146.fa");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8146, STT8146)
//============================================================================


struct  STT8156  {
  long double fa;
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT8156) C1{ FD Fc:3 Fi}



static void Test_STT8156()
{
  {
    init_simple_test("STT8156");
    static STRUCT_IF_C STT8156 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8156)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8156)");
    check_field_offset(lv, fa, 0, "STT8156.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8156");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8156");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8156, STT8156)
//============================================================================


struct  STT8166  {
  long double fa;
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT8166) C1{ FD Fs:3 Fi}



static void Test_STT8166()
{
  {
    init_simple_test("STT8166");
    static STRUCT_IF_C STT8166 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8166)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8166)");
    check_field_offset(lv, fa, 0, "STT8166.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8166");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8166");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8166, STT8166)
//============================================================================


struct  STT8176  {
  long double fa;
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT8176) C1{ FD Fi:3 Fi}



static void Test_STT8176()
{
  {
    init_simple_test("STT8176");
    static STRUCT_IF_C STT8176 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8176)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8176)");
    check_field_offset(lv, fa, 0, "STT8176.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8176");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8176");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8176, STT8176)
//============================================================================


struct  STT8186  {
  long double fa;
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT8186) C1{ FD FL:3 Fi}



static void Test_STT8186()
{
  {
    init_simple_test("STT8186");
    static STRUCT_IF_C STT8186 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8186)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8186)");
    check_field_offset(lv, fa, 0, "STT8186.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8186");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8186");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8186, STT8186)
//============================================================================


struct  STT8196  {
  long double fa;
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT8196) C1{ FD Fs:8 Fi}



static void Test_STT8196()
{
  {
    init_simple_test("STT8196");
    static STRUCT_IF_C STT8196 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8196)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8196)");
    check_field_offset(lv, fa, 0, "STT8196.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8196");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8196");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8196, STT8196)
//============================================================================


struct  STT8206  {
  long double fa;
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT8206) C1{ FD Fi:8 Fi}



static void Test_STT8206()
{
  {
    init_simple_test("STT8206");
    static STRUCT_IF_C STT8206 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8206)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8206)");
    check_field_offset(lv, fa, 0, "STT8206.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8206");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8206");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8206, STT8206)
//============================================================================


struct  STT8216  {
  long double fa;
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT8216) C1{ FD FL:8 Fi}



static void Test_STT8216()
{
  {
    init_simple_test("STT8216");
    static STRUCT_IF_C STT8216 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8216)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8216)");
    check_field_offset(lv, fa, 0, "STT8216.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8216");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8216");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8216, STT8216)
//============================================================================


struct  STT8226  {
  long double fa;
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT8226) C1{ FD Fi:18 Fi}



static void Test_STT8226()
{
  {
    init_simple_test("STT8226");
    static STRUCT_IF_C STT8226 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8226)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8226)");
    check_field_offset(lv, fa, 0, "STT8226.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8226");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8226");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8226, STT8226)
//============================================================================


struct  STT8236  {
  long double fa;
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT8236) C1{ FD FL:18 Fi}



static void Test_STT8236()
{
  {
    init_simple_test("STT8236");
    static STRUCT_IF_C STT8236 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8236)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8236)");
    check_field_offset(lv, fa, 0, "STT8236.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8236");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8236");
    check_field_offset(lv, fb, ABISELECT(20,16), "STT8236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8236, STT8236)
//============================================================================


struct  STT8246  {
  long double fa;
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT8246) C1{ FD FL:48 Fi}



static void Test_STT8246()
{
  {
    init_simple_test("STT8246");
    static STRUCT_IF_C STT8246 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8246)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8246)");
    check_field_offset(lv, fa, 0, "STT8246.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8246");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8246");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8246, STT8246)
//============================================================================


struct  STT817  {
  long double fa;
  unsigned char  :0;
  double fb;
};
//SIG(1 STT817) C1{ FD Fc:0 FL}



static void Test_STT817()
{
  {
    init_simple_test("STT817");
    static STRUCT_IF_C STT817 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT817)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT817)");
    check_field_offset(lv, fa, 0, "STT817.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT817.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT817, STT817)
//============================================================================


struct  STT827  {
  long double fa;
  unsigned short  :0;
  double fb;
};
//SIG(1 STT827) C1{ FD Fs:0 FL}



static void Test_STT827()
{
  {
    init_simple_test("STT827");
    static STRUCT_IF_C STT827 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT827)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT827)");
    check_field_offset(lv, fa, 0, "STT827.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT827.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT827, STT827)
//============================================================================


struct  STT837  {
  long double fa;
  unsigned int  :0;
  double fb;
};
//SIG(1 STT837) C1{ FD Fi:0 FL}



static void Test_STT837()
{
  {
    init_simple_test("STT837");
    static STRUCT_IF_C STT837 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT837)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT837)");
    check_field_offset(lv, fa, 0, "STT837.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT837.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT837, STT837)
//============================================================================


struct  STT847  {
  long double fa;
  __tsu64  :0;
  double fb;
};
//SIG(1 STT847) C1{ FD FL:0 FL}



static void Test_STT847()
{
  {
    init_simple_test("STT847");
    static STRUCT_IF_C STT847 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT847)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT847)");
    check_field_offset(lv, fa, 0, "STT847.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT847.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT847, STT847)
//============================================================================


struct  STT857  {
  long double fa;
  unsigned char  :3;
  double fb;
};
//SIG(1 STT857) C1{ FD Fc:3 FL}



static void Test_STT857()
{
  {
    init_simple_test("STT857");
    static STRUCT_IF_C STT857 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT857)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT857)");
    check_field_offset(lv, fa, 0, "STT857.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT857.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT857, STT857)
//============================================================================


struct  STT867  {
  long double fa;
  unsigned short  :3;
  double fb;
};
//SIG(1 STT867) C1{ FD Fs:3 FL}



static void Test_STT867()
{
  {
    init_simple_test("STT867");
    static STRUCT_IF_C STT867 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT867)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT867)");
    check_field_offset(lv, fa, 0, "STT867.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT867.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT867, STT867)
//============================================================================


struct  STT877  {
  long double fa;
  unsigned int  :3;
  double fb;
};
//SIG(1 STT877) C1{ FD Fi:3 FL}



static void Test_STT877()
{
  {
    init_simple_test("STT877");
    static STRUCT_IF_C STT877 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT877)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT877)");
    check_field_offset(lv, fa, 0, "STT877.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT877.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT877, STT877)
//============================================================================


struct  STT887  {
  long double fa;
  __tsu64  :3;
  double fb;
};
//SIG(1 STT887) C1{ FD FL:3 FL}



static void Test_STT887()
{
  {
    init_simple_test("STT887");
    static STRUCT_IF_C STT887 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT887)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT887)");
    check_field_offset(lv, fa, 0, "STT887.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT887.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT887, STT887)
//============================================================================


struct  STT897  {
  long double fa;
  unsigned short  :8;
  double fb;
};
//SIG(1 STT897) C1{ FD Fs:8 FL}



static void Test_STT897()
{
  {
    init_simple_test("STT897");
    static STRUCT_IF_C STT897 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT897)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT897)");
    check_field_offset(lv, fa, 0, "STT897.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT897.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT897, STT897)
//============================================================================


struct  STT8107  {
  long double fa;
  unsigned int  :8;
  double fb;
};
//SIG(1 STT8107) C1{ FD Fi:8 FL}



static void Test_STT8107()
{
  {
    init_simple_test("STT8107");
    static STRUCT_IF_C STT8107 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8107)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8107)");
    check_field_offset(lv, fa, 0, "STT8107.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8107, STT8107)
//============================================================================


struct  STT8117  {
  long double fa;
  __tsu64  :8;
  double fb;
};
//SIG(1 STT8117) C1{ FD FL:8 FL}



static void Test_STT8117()
{
  {
    init_simple_test("STT8117");
    static STRUCT_IF_C STT8117 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8117)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8117)");
    check_field_offset(lv, fa, 0, "STT8117.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8117, STT8117)
//============================================================================


struct  STT8127  {
  long double fa;
  unsigned int  :18;
  double fb;
};
//SIG(1 STT8127) C1{ FD Fi:18 FL}



static void Test_STT8127()
{
  {
    init_simple_test("STT8127");
    static STRUCT_IF_C STT8127 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8127)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8127)");
    check_field_offset(lv, fa, 0, "STT8127.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8127, STT8127)
//============================================================================


struct  STT8137  {
  long double fa;
  __tsu64  :18;
  double fb;
};
//SIG(1 STT8137) C1{ FD FL:18 FL}



static void Test_STT8137()
{
  {
    init_simple_test("STT8137");
    static STRUCT_IF_C STT8137 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8137)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8137)");
    check_field_offset(lv, fa, 0, "STT8137.fa");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8137, STT8137)
//============================================================================


struct  STT8147  {
  long double fa;
  __tsu64  :48;
  double fb;
};
//SIG(1 STT8147) C1{ FD FL:48 FL}



static void Test_STT8147()
{
  {
    init_simple_test("STT8147");
    static STRUCT_IF_C STT8147 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT8147)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8147)");
    check_field_offset(lv, fa, 0, "STT8147.fa");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8147, STT8147)
//============================================================================


struct  STT8157  {
  long double fa;
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT8157) C1{ FD Fc:3 FL}



static void Test_STT8157()
{
  {
    init_simple_test("STT8157");
    static STRUCT_IF_C STT8157 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8157)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8157)");
    check_field_offset(lv, fa, 0, "STT8157.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8157");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8157");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8157, STT8157)
//============================================================================


struct  STT8167  {
  long double fa;
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT8167) C1{ FD Fs:3 FL}



static void Test_STT8167()
{
  {
    init_simple_test("STT8167");
    static STRUCT_IF_C STT8167 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8167)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8167)");
    check_field_offset(lv, fa, 0, "STT8167.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8167");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8167");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8167, STT8167)
//============================================================================


struct  STT8177  {
  long double fa;
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT8177) C1{ FD Fi:3 FL}



static void Test_STT8177()
{
  {
    init_simple_test("STT8177");
    static STRUCT_IF_C STT8177 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8177)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8177)");
    check_field_offset(lv, fa, 0, "STT8177.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8177");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8177");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8177, STT8177)
//============================================================================


struct  STT8187  {
  long double fa;
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT8187) C1{ FD FL:3 FL}



static void Test_STT8187()
{
  {
    init_simple_test("STT8187");
    static STRUCT_IF_C STT8187 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8187)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8187)");
    check_field_offset(lv, fa, 0, "STT8187.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8187");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8187");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8187, STT8187)
//============================================================================


struct  STT8197  {
  long double fa;
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT8197) C1{ FD Fs:8 FL}



static void Test_STT8197()
{
  {
    init_simple_test("STT8197");
    static STRUCT_IF_C STT8197 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8197)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8197)");
    check_field_offset(lv, fa, 0, "STT8197.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8197");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8197");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8197, STT8197)
//============================================================================


struct  STT8207  {
  long double fa;
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT8207) C1{ FD Fi:8 FL}



static void Test_STT8207()
{
  {
    init_simple_test("STT8207");
    static STRUCT_IF_C STT8207 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8207)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8207)");
    check_field_offset(lv, fa, 0, "STT8207.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8207");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8207");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8207, STT8207)
//============================================================================


struct  STT8217  {
  long double fa;
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT8217) C1{ FD FL:8 FL}



static void Test_STT8217()
{
  {
    init_simple_test("STT8217");
    static STRUCT_IF_C STT8217 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8217)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8217)");
    check_field_offset(lv, fa, 0, "STT8217.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8217");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8217");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8217, STT8217)
//============================================================================


struct  STT8227  {
  long double fa;
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT8227) C1{ FD Fi:18 FL}



static void Test_STT8227()
{
  {
    init_simple_test("STT8227");
    static STRUCT_IF_C STT8227 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8227)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8227)");
    check_field_offset(lv, fa, 0, "STT8227.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8227");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8227");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8227, STT8227)
//============================================================================


struct  STT8237  {
  long double fa;
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT8237) C1{ FD FL:18 FL}



static void Test_STT8237()
{
  {
    init_simple_test("STT8237");
    static STRUCT_IF_C STT8237 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT8237)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8237)");
    check_field_offset(lv, fa, 0, "STT8237.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8237");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8237");
    check_field_offset(lv, fb, ABISELECT(24,16), "STT8237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8237, STT8237)
//============================================================================


struct  STT8247  {
  long double fa;
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT8247) C1{ FD FL:48 FL}



static void Test_STT8247()
{
  {
    init_simple_test("STT8247");
    static STRUCT_IF_C STT8247 lv;
    check2(sizeof(lv), ABISELECT(32,28), "sizeof(STT8247)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8247)");
    check_field_offset(lv, fa, 0, "STT8247.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8247");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8247");
    check_field_offset(lv, fb, ABISELECT(24,20), "STT8247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8247, STT8247)
//============================================================================


struct  STT818  {
  long double fa;
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT818) C1{ FD Fc:0 FD}



static void Test_STT818()
{
  {
    init_simple_test("STT818");
    static STRUCT_IF_C STT818 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT818)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT818)");
    check_field_offset(lv, fa, 0, "STT818.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT818.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT818, STT818)
//============================================================================


struct  STT828  {
  long double fa;
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT828) C1{ FD Fs:0 FD}



static void Test_STT828()
{
  {
    init_simple_test("STT828");
    static STRUCT_IF_C STT828 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT828)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT828)");
    check_field_offset(lv, fa, 0, "STT828.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT828.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT828, STT828)
//============================================================================


struct  STT838  {
  long double fa;
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT838) C1{ FD Fi:0 FD}



static void Test_STT838()
{
  {
    init_simple_test("STT838");
    static STRUCT_IF_C STT838 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT838)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT838)");
    check_field_offset(lv, fa, 0, "STT838.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT838.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT838, STT838)
//============================================================================


struct  STT848  {
  long double fa;
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT848) C1{ FD FL:0 FD}



static void Test_STT848()
{
  {
    init_simple_test("STT848");
    static STRUCT_IF_C STT848 lv;
    check2(sizeof(lv), ABISELECT(32,24), "sizeof(STT848)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT848)");
    check_field_offset(lv, fa, 0, "STT848.fa");
    check_field_offset(lv, fb, ABISELECT(16,12), "STT848.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT848, STT848)
//============================================================================


struct  STT858  {
  long double fa;
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT858) C1{ FD Fc:3 FD}



static void Test_STT858()
{
  {
    init_simple_test("STT858");
    static STRUCT_IF_C STT858 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT858)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT858)");
    check_field_offset(lv, fa, 0, "STT858.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT858.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT858, STT858)
//============================================================================


struct  STT868  {
  long double fa;
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT868) C1{ FD Fs:3 FD}



static void Test_STT868()
{
  {
    init_simple_test("STT868");
    static STRUCT_IF_C STT868 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT868)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT868)");
    check_field_offset(lv, fa, 0, "STT868.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT868.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT868, STT868)
//============================================================================


struct  STT878  {
  long double fa;
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT878) C1{ FD Fi:3 FD}



static void Test_STT878()
{
  {
    init_simple_test("STT878");
    static STRUCT_IF_C STT878 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT878)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT878)");
    check_field_offset(lv, fa, 0, "STT878.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT878.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT878, STT878)
//============================================================================


struct  STT888  {
  long double fa;
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT888) C1{ FD FL:3 FD}



static void Test_STT888()
{
  {
    init_simple_test("STT888");
    static STRUCT_IF_C STT888 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT888)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT888)");
    check_field_offset(lv, fa, 0, "STT888.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT888.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT888, STT888)
//============================================================================


struct  STT898  {
  long double fa;
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT898) C1{ FD Fs:8 FD}



static void Test_STT898()
{
  {
    init_simple_test("STT898");
    static STRUCT_IF_C STT898 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT898)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT898)");
    check_field_offset(lv, fa, 0, "STT898.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT898.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT898, STT898)
//============================================================================


struct  STT8108  {
  long double fa;
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT8108) C1{ FD Fi:8 FD}



static void Test_STT8108()
{
  {
    init_simple_test("STT8108");
    static STRUCT_IF_C STT8108 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8108)");
    check_field_offset(lv, fa, 0, "STT8108.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8108, STT8108)
//============================================================================


struct  STT8118  {
  long double fa;
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT8118) C1{ FD FL:8 FD}



static void Test_STT8118()
{
  {
    init_simple_test("STT8118");
    static STRUCT_IF_C STT8118 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8118)");
    check_field_offset(lv, fa, 0, "STT8118.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8118, STT8118)
//============================================================================


struct  STT8128  {
  long double fa;
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT8128) C1{ FD Fi:18 FD}



static void Test_STT8128()
{
  {
    init_simple_test("STT8128");
    static STRUCT_IF_C STT8128 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8128)");
    check_field_offset(lv, fa, 0, "STT8128.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8128, STT8128)
//============================================================================


struct  STT8138  {
  long double fa;
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT8138) C1{ FD FL:18 FD}



static void Test_STT8138()
{
  {
    init_simple_test("STT8138");
    static STRUCT_IF_C STT8138 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8138)");
    check_field_offset(lv, fa, 0, "STT8138.fa");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8138, STT8138)
//============================================================================


struct  STT8148  {
  long double fa;
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT8148) C1{ FD FL:48 FD}



static void Test_STT8148()
{
  {
    init_simple_test("STT8148");
    static STRUCT_IF_C STT8148 lv;
    check2(sizeof(lv), ABISELECT(48,32), "sizeof(STT8148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8148)");
    check_field_offset(lv, fa, 0, "STT8148.fa");
    check_field_offset(lv, fb, ABISELECT(32,20), "STT8148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8148, STT8148)
//============================================================================


struct  STT8158  {
  long double fa;
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT8158) C1{ FD Fc:3 FD}



static void Test_STT8158()
{
  {
    init_simple_test("STT8158");
    static STRUCT_IF_C STT8158 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8158)");
    check_field_offset(lv, fa, 0, "STT8158.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8158");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8158");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8158, STT8158)
//============================================================================


struct  STT8168  {
  long double fa;
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT8168) C1{ FD Fs:3 FD}



static void Test_STT8168()
{
  {
    init_simple_test("STT8168");
    static STRUCT_IF_C STT8168 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8168)");
    check_field_offset(lv, fa, 0, "STT8168.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8168");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8168");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8168, STT8168)
//============================================================================


struct  STT8178  {
  long double fa;
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT8178) C1{ FD Fi:3 FD}



static void Test_STT8178()
{
  {
    init_simple_test("STT8178");
    static STRUCT_IF_C STT8178 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8178)");
    check_field_offset(lv, fa, 0, "STT8178.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8178");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8178");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8178, STT8178)
//============================================================================


struct  STT8188  {
  long double fa;
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT8188) C1{ FD FL:3 FD}



static void Test_STT8188()
{
  {
    init_simple_test("STT8188");
    static STRUCT_IF_C STT8188 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8188)");
    check_field_offset(lv, fa, 0, "STT8188.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8188");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8188");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8188, STT8188)
//============================================================================


struct  STT8198  {
  long double fa;
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT8198) C1{ FD Fs:8 FD}



static void Test_STT8198()
{
  {
    init_simple_test("STT8198");
    static STRUCT_IF_C STT8198 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8198)");
    check_field_offset(lv, fa, 0, "STT8198.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8198");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8198");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8198, STT8198)
//============================================================================


struct  STT8208  {
  long double fa;
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT8208) C1{ FD Fi:8 FD}



static void Test_STT8208()
{
  {
    init_simple_test("STT8208");
    static STRUCT_IF_C STT8208 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8208)");
    check_field_offset(lv, fa, 0, "STT8208.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8208");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8208");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8208, STT8208)
//============================================================================


struct  STT8218  {
  long double fa;
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT8218) C1{ FD FL:8 FD}



static void Test_STT8218()
{
  {
    init_simple_test("STT8218");
    static STRUCT_IF_C STT8218 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8218)");
    check_field_offset(lv, fa, 0, "STT8218.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8218");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8218");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8218, STT8218)
//============================================================================


struct  STT8228  {
  long double fa;
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT8228) C1{ FD Fi:18 FD}



static void Test_STT8228()
{
  {
    init_simple_test("STT8228");
    static STRUCT_IF_C STT8228 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8228)");
    check_field_offset(lv, fa, 0, "STT8228.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8228");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8228");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8228, STT8228)
//============================================================================


struct  STT8238  {
  long double fa;
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT8238) C1{ FD FL:18 FD}



static void Test_STT8238()
{
  {
    init_simple_test("STT8238");
    static STRUCT_IF_C STT8238 lv;
    check2(sizeof(lv), ABISELECT(48,28), "sizeof(STT8238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8238)");
    check_field_offset(lv, fa, 0, "STT8238.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8238");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8238");
    check_field_offset(lv, fb, ABISELECT(32,16), "STT8238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8238, STT8238)
//============================================================================


struct  STT8248  {
  long double fa;
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT8248) C1{ FD FL:48 FD}



static void Test_STT8248()
{
  {
    init_simple_test("STT8248");
    static STRUCT_IF_C STT8248 lv;
    check2(sizeof(lv), ABISELECT(48,32), "sizeof(STT8248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8248)");
    check_field_offset(lv, fa, 0, "STT8248.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8248");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8248");
    check_field_offset(lv, fb, ABISELECT(32,20), "STT8248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8248, STT8248)
//============================================================================


struct  STT819  {
  long double fa;
  unsigned char  :0;
};
//SIG(1 STT819) C1{ FD Fc:0}



static void Test_STT819()
{
  {
    init_simple_test("STT819");
    static STRUCT_IF_C STT819 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT819)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT819)");
    check_field_offset(lv, fa, 0, "STT819.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT819, STT819)
//============================================================================


struct  STT829  {
  long double fa;
  unsigned short  :0;
};
//SIG(1 STT829) C1{ FD Fs:0}



static void Test_STT829()
{
  {
    init_simple_test("STT829");
    static STRUCT_IF_C STT829 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT829)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT829)");
    check_field_offset(lv, fa, 0, "STT829.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT829, STT829)
//============================================================================


struct  STT839  {
  long double fa;
  unsigned int  :0;
};
//SIG(1 STT839) C1{ FD Fi:0}



static void Test_STT839()
{
  {
    init_simple_test("STT839");
    static STRUCT_IF_C STT839 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT839)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT839)");
    check_field_offset(lv, fa, 0, "STT839.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT839, STT839)
//============================================================================


struct  STT849  {
  long double fa;
  __tsu64  :0;
};
//SIG(1 STT849) C1{ FD FL:0}



static void Test_STT849()
{
  {
    init_simple_test("STT849");
    static STRUCT_IF_C STT849 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT849)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT849)");
    check_field_offset(lv, fa, 0, "STT849.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT849, STT849)
//============================================================================


struct  STT859  {
  long double fa;
  unsigned char  :3;
};
//SIG(1 STT859) C1{ FD Fc:3}



static void Test_STT859()
{
  {
    init_simple_test("STT859");
    static STRUCT_IF_C STT859 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT859)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT859)");
    check_field_offset(lv, fa, 0, "STT859.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT859, STT859)
//============================================================================


struct  STT869  {
  long double fa;
  unsigned short  :3;
};
//SIG(1 STT869) C1{ FD Fs:3}



static void Test_STT869()
{
  {
    init_simple_test("STT869");
    static STRUCT_IF_C STT869 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT869)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT869)");
    check_field_offset(lv, fa, 0, "STT869.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT869, STT869)
//============================================================================


struct  STT879  {
  long double fa;
  unsigned int  :3;
};
//SIG(1 STT879) C1{ FD Fi:3}



static void Test_STT879()
{
  {
    init_simple_test("STT879");
    static STRUCT_IF_C STT879 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT879)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT879)");
    check_field_offset(lv, fa, 0, "STT879.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT879, STT879)
//============================================================================


struct  STT889  {
  long double fa;
  __tsu64  :3;
};
//SIG(1 STT889) C1{ FD FL:3}



static void Test_STT889()
{
  {
    init_simple_test("STT889");
    static STRUCT_IF_C STT889 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT889)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT889)");
    check_field_offset(lv, fa, 0, "STT889.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT889, STT889)
//============================================================================


struct  STT899  {
  long double fa;
  unsigned short  :8;
};
//SIG(1 STT899) C1{ FD Fs:8}



static void Test_STT899()
{
  {
    init_simple_test("STT899");
    static STRUCT_IF_C STT899 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT899)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT899)");
    check_field_offset(lv, fa, 0, "STT899.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT899, STT899)
//============================================================================


struct  STT8109  {
  long double fa;
  unsigned int  :8;
};
//SIG(1 STT8109) C1{ FD Fi:8}



static void Test_STT8109()
{
  {
    init_simple_test("STT8109");
    static STRUCT_IF_C STT8109 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8109)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8109)");
    check_field_offset(lv, fa, 0, "STT8109.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8109, STT8109)
//============================================================================


struct  STT8119  {
  long double fa;
  __tsu64  :8;
};
//SIG(1 STT8119) C1{ FD FL:8}



static void Test_STT8119()
{
  {
    init_simple_test("STT8119");
    static STRUCT_IF_C STT8119 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8119)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8119)");
    check_field_offset(lv, fa, 0, "STT8119.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8119, STT8119)
//============================================================================


struct  STT8129  {
  long double fa;
  unsigned int  :18;
};
//SIG(1 STT8129) C1{ FD Fi:18}



static void Test_STT8129()
{
  {
    init_simple_test("STT8129");
    static STRUCT_IF_C STT8129 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8129)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8129)");
    check_field_offset(lv, fa, 0, "STT8129.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8129, STT8129)
//============================================================================


struct  STT8139  {
  long double fa;
  __tsu64  :18;
};
//SIG(1 STT8139) C1{ FD FL:18}



static void Test_STT8139()
{
  {
    init_simple_test("STT8139");
    static STRUCT_IF_C STT8139 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8139)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8139)");
    check_field_offset(lv, fa, 0, "STT8139.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8139, STT8139)
//============================================================================


struct  STT8149  {
  long double fa;
  __tsu64  :48;
};
//SIG(1 STT8149) C1{ FD FL:48}



static void Test_STT8149()
{
  {
    init_simple_test("STT8149");
    static STRUCT_IF_C STT8149 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8149)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8149)");
    check_field_offset(lv, fa, 0, "STT8149.fa");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8149, STT8149)
//============================================================================


struct  STT8159  {
  long double fa;
  unsigned char bf:3;
};
//SIG(1 STT8159) C1{ FD Fc:3}



static void Test_STT8159()
{
  {
    init_simple_test("STT8159");
    static STRUCT_IF_C STT8159 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8159)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8159)");
    check_field_offset(lv, fa, 0, "STT8159.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8159");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8159, STT8159)
//============================================================================


struct  STT8169  {
  long double fa;
  unsigned short bf:3;
};
//SIG(1 STT8169) C1{ FD Fs:3}



static void Test_STT8169()
{
  {
    init_simple_test("STT8169");
    static STRUCT_IF_C STT8169 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8169)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8169)");
    check_field_offset(lv, fa, 0, "STT8169.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8169");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8169, STT8169)
//============================================================================


struct  STT8179  {
  long double fa;
  unsigned int bf:3;
};
//SIG(1 STT8179) C1{ FD Fi:3}



static void Test_STT8179()
{
  {
    init_simple_test("STT8179");
    static STRUCT_IF_C STT8179 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8179)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8179)");
    check_field_offset(lv, fa, 0, "STT8179.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8179");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8179, STT8179)
//============================================================================


struct  STT8189  {
  long double fa;
  __tsu64 bf:3;
};
//SIG(1 STT8189) C1{ FD FL:3}



static void Test_STT8189()
{
  {
    init_simple_test("STT8189");
    static STRUCT_IF_C STT8189 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8189)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8189)");
    check_field_offset(lv, fa, 0, "STT8189.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, 1, "STT8189");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 3, hide_ull(1LL<<2), "STT8189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8189, STT8189)
//============================================================================


struct  STT8199  {
  long double fa;
  unsigned short bf:8;
};
//SIG(1 STT8199) C1{ FD Fs:8}



static void Test_STT8199()
{
  {
    init_simple_test("STT8199");
    static STRUCT_IF_C STT8199 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8199)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8199)");
    check_field_offset(lv, fa, 0, "STT8199.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8199");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8199, STT8199)
//============================================================================


struct  STT8209  {
  long double fa;
  unsigned int bf:8;
};
//SIG(1 STT8209) C1{ FD Fi:8}



static void Test_STT8209()
{
  {
    init_simple_test("STT8209");
    static STRUCT_IF_C STT8209 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8209)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8209)");
    check_field_offset(lv, fa, 0, "STT8209.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8209");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8209, STT8209)
//============================================================================


struct  STT8219  {
  long double fa;
  __tsu64 bf:8;
};
//SIG(1 STT8219) C1{ FD FL:8}



static void Test_STT8219()
{
  {
    init_simple_test("STT8219");
    static STRUCT_IF_C STT8219 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8219)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8219)");
    check_field_offset(lv, fa, 0, "STT8219.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, 1, "STT8219");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 8, hide_ull(1LL<<7), "STT8219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8219, STT8219)
//============================================================================


struct  STT8229  {
  long double fa;
  unsigned int bf:18;
};
//SIG(1 STT8229) C1{ FD Fi:18}



static void Test_STT8229()
{
  {
    init_simple_test("STT8229");
    static STRUCT_IF_C STT8229 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8229)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8229)");
    check_field_offset(lv, fa, 0, "STT8229.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8229");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8229, STT8229)
//============================================================================


struct  STT8239  {
  long double fa;
  __tsu64 bf:18;
};
//SIG(1 STT8239) C1{ FD FL:18}



static void Test_STT8239()
{
  {
    init_simple_test("STT8239");
    static STRUCT_IF_C STT8239 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT8239)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8239)");
    check_field_offset(lv, fa, 0, "STT8239.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, 1, "STT8239");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 18, hide_ull(1LL<<17), "STT8239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8239, STT8239)
//============================================================================


struct  STT8249  {
  long double fa;
  __tsu64 bf:48;
};
//SIG(1 STT8249) C1{ FD FL:48}



static void Test_STT8249()
{
  {
    init_simple_test("STT8249");
    static STRUCT_IF_C STT8249 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT8249)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT8249)");
    check_field_offset(lv, fa, 0, "STT8249.fa");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, 1, "STT8249");
    set_bf_and_test(lv, bf, ABISELECT(16,12), 0, 48, hide_ull(1LL<<47), "STT8249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT8249, STT8249)
//============================================================================


struct  STT910  {
  unsigned char  :0;
  char fb;
};
//SIG(1 STT910) C1{ Fc:0 Fc}



static void Test_STT910()
{
  {
    init_simple_test("STT910");
    static STRUCT_IF_C STT910 lv;
    check2(sizeof(lv), 1, "sizeof(STT910)");
    check2(__alignof__(lv), 1, "__alignof__(STT910)");
    check_field_offset(lv, fb, 0, "STT910.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT910, STT910)
//============================================================================


struct  STT920  {
  unsigned short  :0;
  char fb;
};
//SIG(1 STT920) C1{ Fs:0 Fc}



static void Test_STT920()
{
  {
    init_simple_test("STT920");
    static STRUCT_IF_C STT920 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT920)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT920)");
    check_field_offset(lv, fb, 0, "STT920.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT920, STT920)
//============================================================================


struct  STT930  {
  unsigned int  :0;
  char fb;
};
//SIG(1 STT930) C1{ Fi:0 Fc}



static void Test_STT930()
{
  {
    init_simple_test("STT930");
    static STRUCT_IF_C STT930 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT930)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT930)");
    check_field_offset(lv, fb, 0, "STT930.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT930, STT930)
//============================================================================


struct  STT940  {
  __tsu64  :0;
  char fb;
};
//SIG(1 STT940) C1{ FL:0 Fc}



static void Test_STT940()
{
  {
    init_simple_test("STT940");
    static STRUCT_IF_C STT940 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT940)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT940)");
    check_field_offset(lv, fb, 0, "STT940.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT940, STT940)
//============================================================================


struct  STT950  {
  unsigned char  :3;
  char fb;
};
//SIG(1 STT950) C1{ Fc:3 Fc}



static void Test_STT950()
{
  {
    init_simple_test("STT950");
    static STRUCT_IF_C STT950 lv;
    check2(sizeof(lv), 2, "sizeof(STT950)");
    check2(__alignof__(lv), 1, "__alignof__(STT950)");
    check_field_offset(lv, fb, 1, "STT950.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT950, STT950)
//============================================================================


struct  STT960  {
  unsigned short  :3;
  char fb;
};
//SIG(1 STT960) C1{ Fs:3 Fc}



static void Test_STT960()
{
  {
    init_simple_test("STT960");
    static STRUCT_IF_C STT960 lv;
    check2(sizeof(lv), 2, "sizeof(STT960)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT960)");
    check_field_offset(lv, fb, 1, "STT960.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT960, STT960)
//============================================================================


struct  STT970  {
  unsigned int  :3;
  char fb;
};
//SIG(1 STT970) C1{ Fi:3 Fc}



static void Test_STT970()
{
  {
    init_simple_test("STT970");
    static STRUCT_IF_C STT970 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT970)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT970)");
    check_field_offset(lv, fb, 1, "STT970.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT970, STT970)
//============================================================================


struct  STT980  {
  __tsu64  :3;
  char fb;
};
//SIG(1 STT980) C1{ FL:3 Fc}



static void Test_STT980()
{
  {
    init_simple_test("STT980");
    static STRUCT_IF_C STT980 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT980)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT980)");
    check_field_offset(lv, fb, 1, "STT980.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT980, STT980)
//============================================================================


struct  STT990  {
  unsigned short  :8;
  char fb;
};
//SIG(1 STT990) C1{ Fs:8 Fc}



static void Test_STT990()
{
  {
    init_simple_test("STT990");
    static STRUCT_IF_C STT990 lv;
    check2(sizeof(lv), 2, "sizeof(STT990)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT990)");
    check_field_offset(lv, fb, 1, "STT990.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT990, STT990)
//============================================================================


struct  STT9100  {
  unsigned int  :8;
  char fb;
};
//SIG(1 STT9100) C1{ Fi:8 Fc}



static void Test_STT9100()
{
  {
    init_simple_test("STT9100");
    static STRUCT_IF_C STT9100 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT9100)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9100)");
    check_field_offset(lv, fb, 1, "STT9100.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9100, STT9100)
//============================================================================


struct  STT9110  {
  __tsu64  :8;
  char fb;
};
//SIG(1 STT9110) C1{ FL:8 Fc}



static void Test_STT9110()
{
  {
    init_simple_test("STT9110");
    static STRUCT_IF_C STT9110 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT9110)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9110)");
    check_field_offset(lv, fb, 1, "STT9110.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9110, STT9110)
//============================================================================


struct  STT9120  {
  unsigned int  :18;
  char fb;
};
//SIG(1 STT9120) C1{ Fi:18 Fc}



static void Test_STT9120()
{
  {
    init_simple_test("STT9120");
    static STRUCT_IF_C STT9120 lv;
    check2(sizeof(lv), 4, "sizeof(STT9120)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9120)");
    check_field_offset(lv, fb, 3, "STT9120.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9120, STT9120)
//============================================================================


struct  STT9130  {
  __tsu64  :18;
  char fb;
};
//SIG(1 STT9130) C1{ FL:18 Fc}



static void Test_STT9130()
{
  {
    init_simple_test("STT9130");
    static STRUCT_IF_C STT9130 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT9130)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9130)");
    check_field_offset(lv, fb, 3, "STT9130.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9130, STT9130)
//============================================================================


struct  STT9140  {
  __tsu64  :48;
  char fb;
};
//SIG(1 STT9140) C1{ FL:48 Fc}



static void Test_STT9140()
{
  {
    init_simple_test("STT9140");
    static STRUCT_IF_C STT9140 lv;
    check2(sizeof(lv), ABISELECT(7,7), "sizeof(STT9140)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9140)");
    check_field_offset(lv, fb, 6, "STT9140.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9140, STT9140)
//============================================================================


struct  STT9150  {
  unsigned char bf:3;
  char fb;
};
//SIG(1 STT9150) C1{ Fc:3 Fc}



static void Test_STT9150()
{
  {
    init_simple_test("STT9150");
    static STRUCT_IF_C STT9150 lv;
    check2(sizeof(lv), 2, "sizeof(STT9150)");
    check2(__alignof__(lv), 1, "__alignof__(STT9150)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9150");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9150");
    check_field_offset(lv, fb, 1, "STT9150.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9150, STT9150)
//============================================================================


struct  STT9160  {
  unsigned short bf:3;
  char fb;
};
//SIG(1 STT9160) C1{ Fs:3 Fc}



static void Test_STT9160()
{
  {
    init_simple_test("STT9160");
    static STRUCT_IF_C STT9160 lv;
    check2(sizeof(lv), 2, "sizeof(STT9160)");
    check2(__alignof__(lv), 2, "__alignof__(STT9160)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9160");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9160");
    check_field_offset(lv, fb, 1, "STT9160.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9160, STT9160)
//============================================================================


struct  STT9170  {
  unsigned int bf:3;
  char fb;
};
//SIG(1 STT9170) C1{ Fi:3 Fc}



static void Test_STT9170()
{
  {
    init_simple_test("STT9170");
    static STRUCT_IF_C STT9170 lv;
    check2(sizeof(lv), 4, "sizeof(STT9170)");
    check2(__alignof__(lv), 4, "__alignof__(STT9170)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9170");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9170");
    check_field_offset(lv, fb, 1, "STT9170.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9170, STT9170)
//============================================================================


struct  STT9180  {
  __tsu64 bf:3;
  char fb;
};
//SIG(1 STT9180) C1{ FL:3 Fc}



static void Test_STT9180()
{
  {
    init_simple_test("STT9180");
    static STRUCT_IF_C STT9180 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9180)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9180)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9180");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9180");
    check_field_offset(lv, fb, 1, "STT9180.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9180, STT9180)
//============================================================================


struct  STT9190  {
  unsigned short bf:8;
  char fb;
};
//SIG(1 STT9190) C1{ Fs:8 Fc}



static void Test_STT9190()
{
  {
    init_simple_test("STT9190");
    static STRUCT_IF_C STT9190 lv;
    check2(sizeof(lv), 2, "sizeof(STT9190)");
    check2(__alignof__(lv), 2, "__alignof__(STT9190)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9190");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9190");
    check_field_offset(lv, fb, 1, "STT9190.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9190, STT9190)
//============================================================================


struct  STT9200  {
  unsigned int bf:8;
  char fb;
};
//SIG(1 STT9200) C1{ Fi:8 Fc}



static void Test_STT9200()
{
  {
    init_simple_test("STT9200");
    static STRUCT_IF_C STT9200 lv;
    check2(sizeof(lv), 4, "sizeof(STT9200)");
    check2(__alignof__(lv), 4, "__alignof__(STT9200)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9200");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9200");
    check_field_offset(lv, fb, 1, "STT9200.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9200, STT9200)
//============================================================================


struct  STT9210  {
  __tsu64 bf:8;
  char fb;
};
//SIG(1 STT9210) C1{ FL:8 Fc}



static void Test_STT9210()
{
  {
    init_simple_test("STT9210");
    static STRUCT_IF_C STT9210 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9210)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9210)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9210");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9210");
    check_field_offset(lv, fb, 1, "STT9210.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9210, STT9210)
//============================================================================


struct  STT9220  {
  unsigned int bf:18;
  char fb;
};
//SIG(1 STT9220) C1{ Fi:18 Fc}



static void Test_STT9220()
{
  {
    init_simple_test("STT9220");
    static STRUCT_IF_C STT9220 lv;
    check2(sizeof(lv), 4, "sizeof(STT9220)");
    check2(__alignof__(lv), 4, "__alignof__(STT9220)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9220");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9220");
    check_field_offset(lv, fb, 3, "STT9220.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9220, STT9220)
//============================================================================


struct  STT9230  {
  __tsu64 bf:18;
  char fb;
};
//SIG(1 STT9230) C1{ FL:18 Fc}



static void Test_STT9230()
{
  {
    init_simple_test("STT9230");
    static STRUCT_IF_C STT9230 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9230)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9230)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9230");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9230");
    check_field_offset(lv, fb, 3, "STT9230.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9230, STT9230)
//============================================================================


struct  STT9240  {
  __tsu64 bf:48;
  char fb;
};
//SIG(1 STT9240) C1{ FL:48 Fc}



static void Test_STT9240()
{
  {
    init_simple_test("STT9240");
    static STRUCT_IF_C STT9240 lv;
    check2(sizeof(lv), 8, "sizeof(STT9240)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9240)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9240");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9240");
    check_field_offset(lv, fb, 6, "STT9240.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9240, STT9240)
//============================================================================


struct  STT911  {
  unsigned char  :0;
  short fb;
};
//SIG(1 STT911) C1{ Fc:0 Fs}



static void Test_STT911()
{
  {
    init_simple_test("STT911");
    static STRUCT_IF_C STT911 lv;
    check2(sizeof(lv), 2, "sizeof(STT911)");
    check2(__alignof__(lv), 2, "__alignof__(STT911)");
    check_field_offset(lv, fb, 0, "STT911.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT911, STT911)
//============================================================================


struct  STT921  {
  unsigned short  :0;
  short fb;
};
//SIG(1 STT921) C1{ Fs:0 Fs}



static void Test_STT921()
{
  {
    init_simple_test("STT921");
    static STRUCT_IF_C STT921 lv;
    check2(sizeof(lv), 2, "sizeof(STT921)");
    check2(__alignof__(lv), 2, "__alignof__(STT921)");
    check_field_offset(lv, fb, 0, "STT921.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT921, STT921)
//============================================================================


struct  STT931  {
  unsigned int  :0;
  short fb;
};
//SIG(1 STT931) C1{ Fi:0 Fs}



static void Test_STT931()
{
  {
    init_simple_test("STT931");
    static STRUCT_IF_C STT931 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT931)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT931)");
    check_field_offset(lv, fb, 0, "STT931.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT931, STT931)
//============================================================================


struct  STT941  {
  __tsu64  :0;
  short fb;
};
//SIG(1 STT941) C1{ FL:0 Fs}



static void Test_STT941()
{
  {
    init_simple_test("STT941");
    static STRUCT_IF_C STT941 lv;
    check2(sizeof(lv), ABISELECT(2,2), "sizeof(STT941)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT941)");
    check_field_offset(lv, fb, 0, "STT941.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT941, STT941)
//============================================================================


struct  STT951  {
  unsigned char  :3;
  short fb;
};
//SIG(1 STT951) C1{ Fc:3 Fs}



static void Test_STT951()
{
  {
    init_simple_test("STT951");
    static STRUCT_IF_C STT951 lv;
    check2(sizeof(lv), 4, "sizeof(STT951)");
    check2(__alignof__(lv), 2, "__alignof__(STT951)");
    check_field_offset(lv, fb, 2, "STT951.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT951, STT951)
//============================================================================


struct  STT961  {
  unsigned short  :3;
  short fb;
};
//SIG(1 STT961) C1{ Fs:3 Fs}



static void Test_STT961()
{
  {
    init_simple_test("STT961");
    static STRUCT_IF_C STT961 lv;
    check2(sizeof(lv), 4, "sizeof(STT961)");
    check2(__alignof__(lv), 2, "__alignof__(STT961)");
    check_field_offset(lv, fb, 2, "STT961.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT961, STT961)
//============================================================================


struct  STT971  {
  unsigned int  :3;
  short fb;
};
//SIG(1 STT971) C1{ Fi:3 Fs}



static void Test_STT971()
{
  {
    init_simple_test("STT971");
    static STRUCT_IF_C STT971 lv;
    check2(sizeof(lv), 4, "sizeof(STT971)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT971)");
    check_field_offset(lv, fb, 2, "STT971.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT971, STT971)
//============================================================================


struct  STT981  {
  __tsu64  :3;
  short fb;
};
//SIG(1 STT981) C1{ FL:3 Fs}



static void Test_STT981()
{
  {
    init_simple_test("STT981");
    static STRUCT_IF_C STT981 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT981)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT981)");
    check_field_offset(lv, fb, 2, "STT981.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT981, STT981)
//============================================================================


struct  STT991  {
  unsigned short  :8;
  short fb;
};
//SIG(1 STT991) C1{ Fs:8 Fs}



static void Test_STT991()
{
  {
    init_simple_test("STT991");
    static STRUCT_IF_C STT991 lv;
    check2(sizeof(lv), 4, "sizeof(STT991)");
    check2(__alignof__(lv), 2, "__alignof__(STT991)");
    check_field_offset(lv, fb, 2, "STT991.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT991, STT991)
//============================================================================


struct  STT9101  {
  unsigned int  :8;
  short fb;
};
//SIG(1 STT9101) C1{ Fi:8 Fs}



static void Test_STT9101()
{
  {
    init_simple_test("STT9101");
    static STRUCT_IF_C STT9101 lv;
    check2(sizeof(lv), 4, "sizeof(STT9101)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT9101)");
    check_field_offset(lv, fb, 2, "STT9101.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9101, STT9101)
//============================================================================


struct  STT9111  {
  __tsu64  :8;
  short fb;
};
//SIG(1 STT9111) C1{ FL:8 Fs}



static void Test_STT9111()
{
  {
    init_simple_test("STT9111");
    static STRUCT_IF_C STT9111 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT9111)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT9111)");
    check_field_offset(lv, fb, 2, "STT9111.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9111, STT9111)
//============================================================================


struct  STT9121  {
  unsigned int  :18;
  short fb;
};
//SIG(1 STT9121) C1{ Fi:18 Fs}



static void Test_STT9121()
{
  {
    init_simple_test("STT9121");
    static STRUCT_IF_C STT9121 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT9121)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT9121)");
    check_field_offset(lv, fb, 4, "STT9121.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9121, STT9121)
//============================================================================


struct  STT9131  {
  __tsu64  :18;
  short fb;
};
//SIG(1 STT9131) C1{ FL:18 Fs}



static void Test_STT9131()
{
  {
    init_simple_test("STT9131");
    static STRUCT_IF_C STT9131 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT9131)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT9131)");
    check_field_offset(lv, fb, 4, "STT9131.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9131, STT9131)
//============================================================================


struct  STT9141  {
  __tsu64  :48;
  short fb;
};
//SIG(1 STT9141) C1{ FL:48 Fs}



static void Test_STT9141()
{
  {
    init_simple_test("STT9141");
    static STRUCT_IF_C STT9141 lv;
    check2(sizeof(lv), 8, "sizeof(STT9141)");
    check2(__alignof__(lv), ABISELECT(2,2), "__alignof__(STT9141)");
    check_field_offset(lv, fb, 6, "STT9141.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9141, STT9141)
//============================================================================


struct  STT9151  {
  unsigned char bf:3;
  short fb;
};
//SIG(1 STT9151) C1{ Fc:3 Fs}



static void Test_STT9151()
{
  {
    init_simple_test("STT9151");
    static STRUCT_IF_C STT9151 lv;
    check2(sizeof(lv), 4, "sizeof(STT9151)");
    check2(__alignof__(lv), 2, "__alignof__(STT9151)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9151");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9151");
    check_field_offset(lv, fb, 2, "STT9151.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9151, STT9151)
//============================================================================


struct  STT9161  {
  unsigned short bf:3;
  short fb;
};
//SIG(1 STT9161) C1{ Fs:3 Fs}



static void Test_STT9161()
{
  {
    init_simple_test("STT9161");
    static STRUCT_IF_C STT9161 lv;
    check2(sizeof(lv), 4, "sizeof(STT9161)");
    check2(__alignof__(lv), 2, "__alignof__(STT9161)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9161");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9161");
    check_field_offset(lv, fb, 2, "STT9161.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9161, STT9161)
//============================================================================


struct  STT9171  {
  unsigned int bf:3;
  short fb;
};
//SIG(1 STT9171) C1{ Fi:3 Fs}



static void Test_STT9171()
{
  {
    init_simple_test("STT9171");
    static STRUCT_IF_C STT9171 lv;
    check2(sizeof(lv), 4, "sizeof(STT9171)");
    check2(__alignof__(lv), 4, "__alignof__(STT9171)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9171");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9171");
    check_field_offset(lv, fb, 2, "STT9171.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9171, STT9171)
//============================================================================


struct  STT9181  {
  __tsu64 bf:3;
  short fb;
};
//SIG(1 STT9181) C1{ FL:3 Fs}



static void Test_STT9181()
{
  {
    init_simple_test("STT9181");
    static STRUCT_IF_C STT9181 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9181)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9181)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9181");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9181");
    check_field_offset(lv, fb, 2, "STT9181.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9181, STT9181)
//============================================================================


struct  STT9191  {
  unsigned short bf:8;
  short fb;
};
//SIG(1 STT9191) C1{ Fs:8 Fs}



static void Test_STT9191()
{
  {
    init_simple_test("STT9191");
    static STRUCT_IF_C STT9191 lv;
    check2(sizeof(lv), 4, "sizeof(STT9191)");
    check2(__alignof__(lv), 2, "__alignof__(STT9191)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9191");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9191");
    check_field_offset(lv, fb, 2, "STT9191.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9191, STT9191)
//============================================================================


struct  STT9201  {
  unsigned int bf:8;
  short fb;
};
//SIG(1 STT9201) C1{ Fi:8 Fs}



static void Test_STT9201()
{
  {
    init_simple_test("STT9201");
    static STRUCT_IF_C STT9201 lv;
    check2(sizeof(lv), 4, "sizeof(STT9201)");
    check2(__alignof__(lv), 4, "__alignof__(STT9201)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9201");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9201");
    check_field_offset(lv, fb, 2, "STT9201.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9201, STT9201)
//============================================================================


struct  STT9211  {
  __tsu64 bf:8;
  short fb;
};
//SIG(1 STT9211) C1{ FL:8 Fs}



static void Test_STT9211()
{
  {
    init_simple_test("STT9211");
    static STRUCT_IF_C STT9211 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9211)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9211)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9211");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9211");
    check_field_offset(lv, fb, 2, "STT9211.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9211, STT9211)
//============================================================================


struct  STT9221  {
  unsigned int bf:18;
  short fb;
};
//SIG(1 STT9221) C1{ Fi:18 Fs}



static void Test_STT9221()
{
  {
    init_simple_test("STT9221");
    static STRUCT_IF_C STT9221 lv;
    check2(sizeof(lv), 8, "sizeof(STT9221)");
    check2(__alignof__(lv), 4, "__alignof__(STT9221)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9221");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9221");
    check_field_offset(lv, fb, 4, "STT9221.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9221, STT9221)
//============================================================================


struct  STT9231  {
  __tsu64 bf:18;
  short fb;
};
//SIG(1 STT9231) C1{ FL:18 Fs}



static void Test_STT9231()
{
  {
    init_simple_test("STT9231");
    static STRUCT_IF_C STT9231 lv;
    check2(sizeof(lv), 8, "sizeof(STT9231)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9231)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9231");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9231");
    check_field_offset(lv, fb, 4, "STT9231.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9231, STT9231)
//============================================================================


struct  STT9241  {
  __tsu64 bf:48;
  short fb;
};
//SIG(1 STT9241) C1{ FL:48 Fs}



static void Test_STT9241()
{
  {
    init_simple_test("STT9241");
    static STRUCT_IF_C STT9241 lv;
    check2(sizeof(lv), 8, "sizeof(STT9241)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9241)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9241");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9241");
    check_field_offset(lv, fb, 6, "STT9241.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9241, STT9241)
//============================================================================


struct  STT912  {
  unsigned char  :0;
  int fb;
};
//SIG(1 STT912) C1{ Fc:0 Fi}



static void Test_STT912()
{
  {
    init_simple_test("STT912");
    static STRUCT_IF_C STT912 lv;
    check2(sizeof(lv), 4, "sizeof(STT912)");
    check2(__alignof__(lv), 4, "__alignof__(STT912)");
    check_field_offset(lv, fb, 0, "STT912.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT912, STT912)
//============================================================================


struct  STT922  {
  unsigned short  :0;
  int fb;
};
//SIG(1 STT922) C1{ Fs:0 Fi}



static void Test_STT922()
{
  {
    init_simple_test("STT922");
    static STRUCT_IF_C STT922 lv;
    check2(sizeof(lv), 4, "sizeof(STT922)");
    check2(__alignof__(lv), 4, "__alignof__(STT922)");
    check_field_offset(lv, fb, 0, "STT922.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT922, STT922)
//============================================================================


struct  STT932  {
  unsigned int  :0;
  int fb;
};
//SIG(1 STT932) C1{ Fi:0 Fi}



static void Test_STT932()
{
  {
    init_simple_test("STT932");
    static STRUCT_IF_C STT932 lv;
    check2(sizeof(lv), 4, "sizeof(STT932)");
    check2(__alignof__(lv), 4, "__alignof__(STT932)");
    check_field_offset(lv, fb, 0, "STT932.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT932, STT932)
//============================================================================


struct  STT942  {
  __tsu64  :0;
  int fb;
};
//SIG(1 STT942) C1{ FL:0 Fi}



static void Test_STT942()
{
  {
    init_simple_test("STT942");
    static STRUCT_IF_C STT942 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT942)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT942)");
    check_field_offset(lv, fb, 0, "STT942.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT942, STT942)
//============================================================================


struct  STT952  {
  unsigned char  :3;
  int fb;
};
//SIG(1 STT952) C1{ Fc:3 Fi}



static void Test_STT952()
{
  {
    init_simple_test("STT952");
    static STRUCT_IF_C STT952 lv;
    check2(sizeof(lv), 8, "sizeof(STT952)");
    check2(__alignof__(lv), 4, "__alignof__(STT952)");
    check_field_offset(lv, fb, 4, "STT952.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT952, STT952)
//============================================================================


struct  STT962  {
  unsigned short  :3;
  int fb;
};
//SIG(1 STT962) C1{ Fs:3 Fi}



static void Test_STT962()
{
  {
    init_simple_test("STT962");
    static STRUCT_IF_C STT962 lv;
    check2(sizeof(lv), 8, "sizeof(STT962)");
    check2(__alignof__(lv), 4, "__alignof__(STT962)");
    check_field_offset(lv, fb, 4, "STT962.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT962, STT962)
//============================================================================


struct  STT972  {
  unsigned int  :3;
  int fb;
};
//SIG(1 STT972) C1{ Fi:3 Fi}



static void Test_STT972()
{
  {
    init_simple_test("STT972");
    static STRUCT_IF_C STT972 lv;
    check2(sizeof(lv), 8, "sizeof(STT972)");
    check2(__alignof__(lv), 4, "__alignof__(STT972)");
    check_field_offset(lv, fb, 4, "STT972.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT972, STT972)
//============================================================================


struct  STT982  {
  __tsu64  :3;
  int fb;
};
//SIG(1 STT982) C1{ FL:3 Fi}



static void Test_STT982()
{
  {
    init_simple_test("STT982");
    static STRUCT_IF_C STT982 lv;
    check2(sizeof(lv), 8, "sizeof(STT982)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT982)");
    check_field_offset(lv, fb, 4, "STT982.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT982, STT982)
//============================================================================


struct  STT992  {
  unsigned short  :8;
  int fb;
};
//SIG(1 STT992) C1{ Fs:8 Fi}



static void Test_STT992()
{
  {
    init_simple_test("STT992");
    static STRUCT_IF_C STT992 lv;
    check2(sizeof(lv), 8, "sizeof(STT992)");
    check2(__alignof__(lv), 4, "__alignof__(STT992)");
    check_field_offset(lv, fb, 4, "STT992.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT992, STT992)
//============================================================================


struct  STT9102  {
  unsigned int  :8;
  int fb;
};
//SIG(1 STT9102) C1{ Fi:8 Fi}



static void Test_STT9102()
{
  {
    init_simple_test("STT9102");
    static STRUCT_IF_C STT9102 lv;
    check2(sizeof(lv), 8, "sizeof(STT9102)");
    check2(__alignof__(lv), 4, "__alignof__(STT9102)");
    check_field_offset(lv, fb, 4, "STT9102.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9102, STT9102)
//============================================================================


struct  STT9112  {
  __tsu64  :8;
  int fb;
};
//SIG(1 STT9112) C1{ FL:8 Fi}



static void Test_STT9112()
{
  {
    init_simple_test("STT9112");
    static STRUCT_IF_C STT9112 lv;
    check2(sizeof(lv), 8, "sizeof(STT9112)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT9112)");
    check_field_offset(lv, fb, 4, "STT9112.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9112, STT9112)
//============================================================================


struct  STT9122  {
  unsigned int  :18;
  int fb;
};
//SIG(1 STT9122) C1{ Fi:18 Fi}



static void Test_STT9122()
{
  {
    init_simple_test("STT9122");
    static STRUCT_IF_C STT9122 lv;
    check2(sizeof(lv), 8, "sizeof(STT9122)");
    check2(__alignof__(lv), 4, "__alignof__(STT9122)");
    check_field_offset(lv, fb, 4, "STT9122.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9122, STT9122)
//============================================================================


struct  STT9132  {
  __tsu64  :18;
  int fb;
};
//SIG(1 STT9132) C1{ FL:18 Fi}



static void Test_STT9132()
{
  {
    init_simple_test("STT9132");
    static STRUCT_IF_C STT9132 lv;
    check2(sizeof(lv), 8, "sizeof(STT9132)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT9132)");
    check_field_offset(lv, fb, 4, "STT9132.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9132, STT9132)
//============================================================================


struct  STT9142  {
  __tsu64  :48;
  int fb;
};
//SIG(1 STT9142) C1{ FL:48 Fi}



static void Test_STT9142()
{
  {
    init_simple_test("STT9142");
    static STRUCT_IF_C STT9142 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT9142)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT9142)");
    check_field_offset(lv, fb, 8, "STT9142.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9142, STT9142)
//============================================================================


struct  STT9152  {
  unsigned char bf:3;
  int fb;
};
//SIG(1 STT9152) C1{ Fc:3 Fi}



static void Test_STT9152()
{
  {
    init_simple_test("STT9152");
    static STRUCT_IF_C STT9152 lv;
    check2(sizeof(lv), 8, "sizeof(STT9152)");
    check2(__alignof__(lv), 4, "__alignof__(STT9152)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9152");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9152");
    check_field_offset(lv, fb, 4, "STT9152.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9152, STT9152)
//============================================================================


struct  STT9162  {
  unsigned short bf:3;
  int fb;
};
//SIG(1 STT9162) C1{ Fs:3 Fi}



static void Test_STT9162()
{
  {
    init_simple_test("STT9162");
    static STRUCT_IF_C STT9162 lv;
    check2(sizeof(lv), 8, "sizeof(STT9162)");
    check2(__alignof__(lv), 4, "__alignof__(STT9162)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9162");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9162");
    check_field_offset(lv, fb, 4, "STT9162.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9162, STT9162)
//============================================================================


struct  STT9172  {
  unsigned int bf:3;
  int fb;
};
//SIG(1 STT9172) C1{ Fi:3 Fi}



static void Test_STT9172()
{
  {
    init_simple_test("STT9172");
    static STRUCT_IF_C STT9172 lv;
    check2(sizeof(lv), 8, "sizeof(STT9172)");
    check2(__alignof__(lv), 4, "__alignof__(STT9172)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9172");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9172");
    check_field_offset(lv, fb, 4, "STT9172.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9172, STT9172)
//============================================================================


struct  STT9182  {
  __tsu64 bf:3;
  int fb;
};
//SIG(1 STT9182) C1{ FL:3 Fi}



static void Test_STT9182()
{
  {
    init_simple_test("STT9182");
    static STRUCT_IF_C STT9182 lv;
    check2(sizeof(lv), 8, "sizeof(STT9182)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9182)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9182");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9182");
    check_field_offset(lv, fb, 4, "STT9182.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9182, STT9182)
//============================================================================


struct  STT9192  {
  unsigned short bf:8;
  int fb;
};
//SIG(1 STT9192) C1{ Fs:8 Fi}



static void Test_STT9192()
{
  {
    init_simple_test("STT9192");
    static STRUCT_IF_C STT9192 lv;
    check2(sizeof(lv), 8, "sizeof(STT9192)");
    check2(__alignof__(lv), 4, "__alignof__(STT9192)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9192");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9192");
    check_field_offset(lv, fb, 4, "STT9192.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9192, STT9192)
//============================================================================


struct  STT9202  {
  unsigned int bf:8;
  int fb;
};
//SIG(1 STT9202) C1{ Fi:8 Fi}



static void Test_STT9202()
{
  {
    init_simple_test("STT9202");
    static STRUCT_IF_C STT9202 lv;
    check2(sizeof(lv), 8, "sizeof(STT9202)");
    check2(__alignof__(lv), 4, "__alignof__(STT9202)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9202");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9202");
    check_field_offset(lv, fb, 4, "STT9202.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9202, STT9202)
//============================================================================


struct  STT9212  {
  __tsu64 bf:8;
  int fb;
};
//SIG(1 STT9212) C1{ FL:8 Fi}



static void Test_STT9212()
{
  {
    init_simple_test("STT9212");
    static STRUCT_IF_C STT9212 lv;
    check2(sizeof(lv), 8, "sizeof(STT9212)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9212)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9212");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9212");
    check_field_offset(lv, fb, 4, "STT9212.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9212, STT9212)
//============================================================================


struct  STT9222  {
  unsigned int bf:18;
  int fb;
};
//SIG(1 STT9222) C1{ Fi:18 Fi}



static void Test_STT9222()
{
  {
    init_simple_test("STT9222");
    static STRUCT_IF_C STT9222 lv;
    check2(sizeof(lv), 8, "sizeof(STT9222)");
    check2(__alignof__(lv), 4, "__alignof__(STT9222)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9222");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9222");
    check_field_offset(lv, fb, 4, "STT9222.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9222, STT9222)
//============================================================================


struct  STT9232  {
  __tsu64 bf:18;
  int fb;
};
//SIG(1 STT9232) C1{ FL:18 Fi}



static void Test_STT9232()
{
  {
    init_simple_test("STT9232");
    static STRUCT_IF_C STT9232 lv;
    check2(sizeof(lv), 8, "sizeof(STT9232)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9232)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9232");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9232");
    check_field_offset(lv, fb, 4, "STT9232.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9232, STT9232)
//============================================================================


struct  STT9242  {
  __tsu64 bf:48;
  int fb;
};
//SIG(1 STT9242) C1{ FL:48 Fi}



static void Test_STT9242()
{
  {
    init_simple_test("STT9242");
    static STRUCT_IF_C STT9242 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9242)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9242)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9242");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9242");
    check_field_offset(lv, fb, 8, "STT9242.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9242, STT9242)
//============================================================================


struct  STT913  {
  unsigned char  :0;
  long fb;
};
//SIG(1 STT913) C1{ Fc:0 Fl}



static void Test_STT913()
{
  {
    init_simple_test("STT913");
    static STRUCT_IF_C STT913 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT913)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT913)");
    check_field_offset(lv, fb, 0, "STT913.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT913, STT913)
//============================================================================


struct  STT923  {
  unsigned short  :0;
  long fb;
};
//SIG(1 STT923) C1{ Fs:0 Fl}



static void Test_STT923()
{
  {
    init_simple_test("STT923");
    static STRUCT_IF_C STT923 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT923)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT923)");
    check_field_offset(lv, fb, 0, "STT923.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT923, STT923)
//============================================================================


struct  STT933  {
  unsigned int  :0;
  long fb;
};
//SIG(1 STT933) C1{ Fi:0 Fl}



static void Test_STT933()
{
  {
    init_simple_test("STT933");
    static STRUCT_IF_C STT933 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT933)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT933)");
    check_field_offset(lv, fb, 0, "STT933.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT933, STT933)
//============================================================================


struct  STT943  {
  __tsu64  :0;
  long fb;
};
//SIG(1 STT943) C1{ FL:0 Fl}



static void Test_STT943()
{
  {
    init_simple_test("STT943");
    static STRUCT_IF_C STT943 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT943)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT943)");
    check_field_offset(lv, fb, 0, "STT943.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT943, STT943)
//============================================================================


struct  STT953  {
  unsigned char  :3;
  long fb;
};
//SIG(1 STT953) C1{ Fc:3 Fl}



static void Test_STT953()
{
  {
    init_simple_test("STT953");
    static STRUCT_IF_C STT953 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT953)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT953)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT953.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT953, STT953)
//============================================================================


struct  STT963  {
  unsigned short  :3;
  long fb;
};
//SIG(1 STT963) C1{ Fs:3 Fl}



static void Test_STT963()
{
  {
    init_simple_test("STT963");
    static STRUCT_IF_C STT963 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT963)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT963)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT963.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT963, STT963)
//============================================================================


struct  STT973  {
  unsigned int  :3;
  long fb;
};
//SIG(1 STT973) C1{ Fi:3 Fl}



static void Test_STT973()
{
  {
    init_simple_test("STT973");
    static STRUCT_IF_C STT973 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT973)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT973)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT973.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT973, STT973)
//============================================================================


struct  STT983  {
  __tsu64  :3;
  long fb;
};
//SIG(1 STT983) C1{ FL:3 Fl}



static void Test_STT983()
{
  {
    init_simple_test("STT983");
    static STRUCT_IF_C STT983 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT983)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT983)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT983.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT983, STT983)
//============================================================================


struct  STT993  {
  unsigned short  :8;
  long fb;
};
//SIG(1 STT993) C1{ Fs:8 Fl}



static void Test_STT993()
{
  {
    init_simple_test("STT993");
    static STRUCT_IF_C STT993 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT993)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT993)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT993.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT993, STT993)
//============================================================================


struct  STT9103  {
  unsigned int  :8;
  long fb;
};
//SIG(1 STT9103) C1{ Fi:8 Fl}



static void Test_STT9103()
{
  {
    init_simple_test("STT9103");
    static STRUCT_IF_C STT9103 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9103)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9103)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9103.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9103, STT9103)
//============================================================================


struct  STT9113  {
  __tsu64  :8;
  long fb;
};
//SIG(1 STT9113) C1{ FL:8 Fl}



static void Test_STT9113()
{
  {
    init_simple_test("STT9113");
    static STRUCT_IF_C STT9113 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9113)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9113)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9113.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9113, STT9113)
//============================================================================


struct  STT9123  {
  unsigned int  :18;
  long fb;
};
//SIG(1 STT9123) C1{ Fi:18 Fl}



static void Test_STT9123()
{
  {
    init_simple_test("STT9123");
    static STRUCT_IF_C STT9123 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9123)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9123)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9123.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9123, STT9123)
//============================================================================


struct  STT9133  {
  __tsu64  :18;
  long fb;
};
//SIG(1 STT9133) C1{ FL:18 Fl}



static void Test_STT9133()
{
  {
    init_simple_test("STT9133");
    static STRUCT_IF_C STT9133 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9133)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9133)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9133.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9133, STT9133)
//============================================================================


struct  STT9143  {
  __tsu64  :48;
  long fb;
};
//SIG(1 STT9143) C1{ FL:48 Fl}



static void Test_STT9143()
{
  {
    init_simple_test("STT9143");
    static STRUCT_IF_C STT9143 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9143)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9143)");
    check_field_offset(lv, fb, 8, "STT9143.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9143, STT9143)
//============================================================================


struct  STT9153  {
  unsigned char bf:3;
  long fb;
};
//SIG(1 STT9153) C1{ Fc:3 Fl}



static void Test_STT9153()
{
  {
    init_simple_test("STT9153");
    static STRUCT_IF_C STT9153 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9153)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9153)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9153");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9153");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9153.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9153, STT9153)
//============================================================================


struct  STT9163  {
  unsigned short bf:3;
  long fb;
};
//SIG(1 STT9163) C1{ Fs:3 Fl}



static void Test_STT9163()
{
  {
    init_simple_test("STT9163");
    static STRUCT_IF_C STT9163 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9163)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9163)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9163");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9163");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9163.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9163, STT9163)
//============================================================================


struct  STT9173  {
  unsigned int bf:3;
  long fb;
};
//SIG(1 STT9173) C1{ Fi:3 Fl}



static void Test_STT9173()
{
  {
    init_simple_test("STT9173");
    static STRUCT_IF_C STT9173 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9173)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9173)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9173");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9173");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9173.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9173, STT9173)
//============================================================================


struct  STT9183  {
  __tsu64 bf:3;
  long fb;
};
//SIG(1 STT9183) C1{ FL:3 Fl}



static void Test_STT9183()
{
  {
    init_simple_test("STT9183");
    static STRUCT_IF_C STT9183 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9183)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9183)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9183");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9183");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9183.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9183, STT9183)
//============================================================================


struct  STT9193  {
  unsigned short bf:8;
  long fb;
};
//SIG(1 STT9193) C1{ Fs:8 Fl}



static void Test_STT9193()
{
  {
    init_simple_test("STT9193");
    static STRUCT_IF_C STT9193 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9193)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9193)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9193");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9193");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9193.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9193, STT9193)
//============================================================================


struct  STT9203  {
  unsigned int bf:8;
  long fb;
};
//SIG(1 STT9203) C1{ Fi:8 Fl}



static void Test_STT9203()
{
  {
    init_simple_test("STT9203");
    static STRUCT_IF_C STT9203 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9203)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9203)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9203");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9203");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9203.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9203, STT9203)
//============================================================================


struct  STT9213  {
  __tsu64 bf:8;
  long fb;
};
//SIG(1 STT9213) C1{ FL:8 Fl}



static void Test_STT9213()
{
  {
    init_simple_test("STT9213");
    static STRUCT_IF_C STT9213 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9213)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9213)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9213");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9213");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9213.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9213, STT9213)
//============================================================================


struct  STT9223  {
  unsigned int bf:18;
  long fb;
};
//SIG(1 STT9223) C1{ Fi:18 Fl}



static void Test_STT9223()
{
  {
    init_simple_test("STT9223");
    static STRUCT_IF_C STT9223 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9223)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9223)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9223");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9223");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9223.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9223, STT9223)
//============================================================================


struct  STT9233  {
  __tsu64 bf:18;
  long fb;
};
//SIG(1 STT9233) C1{ FL:18 Fl}



static void Test_STT9233()
{
  {
    init_simple_test("STT9233");
    static STRUCT_IF_C STT9233 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9233)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9233)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9233");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9233");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9233.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9233, STT9233)
//============================================================================


struct  STT9243  {
  __tsu64 bf:48;
  long fb;
};
//SIG(1 STT9243) C1{ FL:48 Fl}



static void Test_STT9243()
{
  {
    init_simple_test("STT9243");
    static STRUCT_IF_C STT9243 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9243)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9243)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9243");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9243");
    check_field_offset(lv, fb, 8, "STT9243.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9243, STT9243)
//============================================================================


struct  STT914  {
  unsigned char  :0;
  __tsi64 fb;
};
//SIG(1 STT914) C1{ Fc:0 FL}



static void Test_STT914()
{
  {
    init_simple_test("STT914");
    static STRUCT_IF_C STT914 lv;
    check2(sizeof(lv), 8, "sizeof(STT914)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT914)");
    check_field_offset(lv, fb, 0, "STT914.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT914, STT914)
//============================================================================


struct  STT924  {
  unsigned short  :0;
  __tsi64 fb;
};
//SIG(1 STT924) C1{ Fs:0 FL}



static void Test_STT924()
{
  {
    init_simple_test("STT924");
    static STRUCT_IF_C STT924 lv;
    check2(sizeof(lv), 8, "sizeof(STT924)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT924)");
    check_field_offset(lv, fb, 0, "STT924.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT924, STT924)
//============================================================================


struct  STT934  {
  unsigned int  :0;
  __tsi64 fb;
};
//SIG(1 STT934) C1{ Fi:0 FL}



static void Test_STT934()
{
  {
    init_simple_test("STT934");
    static STRUCT_IF_C STT934 lv;
    check2(sizeof(lv), 8, "sizeof(STT934)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT934)");
    check_field_offset(lv, fb, 0, "STT934.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT934, STT934)
//============================================================================


struct  STT944  {
  __tsu64  :0;
  __tsi64 fb;
};
//SIG(1 STT944) C1{ FL:0 FL}



static void Test_STT944()
{
  {
    init_simple_test("STT944");
    static STRUCT_IF_C STT944 lv;
    check2(sizeof(lv), 8, "sizeof(STT944)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT944)");
    check_field_offset(lv, fb, 0, "STT944.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT944, STT944)
//============================================================================


struct  STT954  {
  unsigned char  :3;
  __tsi64 fb;
};
//SIG(1 STT954) C1{ Fc:3 FL}



static void Test_STT954()
{
  {
    init_simple_test("STT954");
    static STRUCT_IF_C STT954 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT954)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT954)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT954.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT954, STT954)
//============================================================================


struct  STT964  {
  unsigned short  :3;
  __tsi64 fb;
};
//SIG(1 STT964) C1{ Fs:3 FL}



static void Test_STT964()
{
  {
    init_simple_test("STT964");
    static STRUCT_IF_C STT964 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT964)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT964)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT964.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT964, STT964)
//============================================================================


struct  STT974  {
  unsigned int  :3;
  __tsi64 fb;
};
//SIG(1 STT974) C1{ Fi:3 FL}



static void Test_STT974()
{
  {
    init_simple_test("STT974");
    static STRUCT_IF_C STT974 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT974)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT974)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT974.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT974, STT974)
//============================================================================


struct  STT984  {
  __tsu64  :3;
  __tsi64 fb;
};
//SIG(1 STT984) C1{ FL:3 FL}



static void Test_STT984()
{
  {
    init_simple_test("STT984");
    static STRUCT_IF_C STT984 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT984)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT984)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT984.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT984, STT984)
//============================================================================


struct  STT994  {
  unsigned short  :8;
  __tsi64 fb;
};
//SIG(1 STT994) C1{ Fs:8 FL}



static void Test_STT994()
{
  {
    init_simple_test("STT994");
    static STRUCT_IF_C STT994 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT994)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT994)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT994.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT994, STT994)
//============================================================================


struct  STT9104  {
  unsigned int  :8;
  __tsi64 fb;
};
//SIG(1 STT9104) C1{ Fi:8 FL}



static void Test_STT9104()
{
  {
    init_simple_test("STT9104");
    static STRUCT_IF_C STT9104 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9104)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9104)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9104.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9104, STT9104)
//============================================================================


struct  STT9114  {
  __tsu64  :8;
  __tsi64 fb;
};
//SIG(1 STT9114) C1{ FL:8 FL}



static void Test_STT9114()
{
  {
    init_simple_test("STT9114");
    static STRUCT_IF_C STT9114 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9114)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9114)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9114.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9114, STT9114)
//============================================================================


struct  STT9124  {
  unsigned int  :18;
  __tsi64 fb;
};
//SIG(1 STT9124) C1{ Fi:18 FL}



static void Test_STT9124()
{
  {
    init_simple_test("STT9124");
    static STRUCT_IF_C STT9124 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9124)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9124)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9124.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9124, STT9124)
//============================================================================


struct  STT9134  {
  __tsu64  :18;
  __tsi64 fb;
};
//SIG(1 STT9134) C1{ FL:18 FL}



static void Test_STT9134()
{
  {
    init_simple_test("STT9134");
    static STRUCT_IF_C STT9134 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9134)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9134)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9134.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9134, STT9134)
//============================================================================


struct  STT9144  {
  __tsu64  :48;
  __tsi64 fb;
};
//SIG(1 STT9144) C1{ FL:48 FL}



static void Test_STT9144()
{
  {
    init_simple_test("STT9144");
    static STRUCT_IF_C STT9144 lv;
    check2(sizeof(lv), 16, "sizeof(STT9144)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9144)");
    check_field_offset(lv, fb, 8, "STT9144.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9144, STT9144)
//============================================================================


struct  STT9154  {
  unsigned char bf:3;
  __tsi64 fb;
};
//SIG(1 STT9154) C1{ Fc:3 FL}



static void Test_STT9154()
{
  {
    init_simple_test("STT9154");
    static STRUCT_IF_C STT9154 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9154)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9154)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9154");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9154");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9154.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9154, STT9154)
//============================================================================


struct  STT9164  {
  unsigned short bf:3;
  __tsi64 fb;
};
//SIG(1 STT9164) C1{ Fs:3 FL}



static void Test_STT9164()
{
  {
    init_simple_test("STT9164");
    static STRUCT_IF_C STT9164 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9164)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9164)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9164");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9164");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9164.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9164, STT9164)
//============================================================================


struct  STT9174  {
  unsigned int bf:3;
  __tsi64 fb;
};
//SIG(1 STT9174) C1{ Fi:3 FL}



static void Test_STT9174()
{
  {
    init_simple_test("STT9174");
    static STRUCT_IF_C STT9174 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9174)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9174)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9174");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9174");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9174.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9174, STT9174)
//============================================================================


struct  STT9184  {
  __tsu64 bf:3;
  __tsi64 fb;
};
//SIG(1 STT9184) C1{ FL:3 FL}



static void Test_STT9184()
{
  {
    init_simple_test("STT9184");
    static STRUCT_IF_C STT9184 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9184)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9184)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9184");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9184");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9184.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9184, STT9184)
//============================================================================


struct  STT9194  {
  unsigned short bf:8;
  __tsi64 fb;
};
//SIG(1 STT9194) C1{ Fs:8 FL}



static void Test_STT9194()
{
  {
    init_simple_test("STT9194");
    static STRUCT_IF_C STT9194 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9194)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9194)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9194");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9194");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9194.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9194, STT9194)
//============================================================================


struct  STT9204  {
  unsigned int bf:8;
  __tsi64 fb;
};
//SIG(1 STT9204) C1{ Fi:8 FL}



static void Test_STT9204()
{
  {
    init_simple_test("STT9204");
    static STRUCT_IF_C STT9204 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9204)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9204)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9204");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9204");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9204.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9204, STT9204)
//============================================================================


struct  STT9214  {
  __tsu64 bf:8;
  __tsi64 fb;
};
//SIG(1 STT9214) C1{ FL:8 FL}



static void Test_STT9214()
{
  {
    init_simple_test("STT9214");
    static STRUCT_IF_C STT9214 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9214)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9214)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9214");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9214");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9214.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9214, STT9214)
//============================================================================


struct  STT9224  {
  unsigned int bf:18;
  __tsi64 fb;
};
//SIG(1 STT9224) C1{ Fi:18 FL}



static void Test_STT9224()
{
  {
    init_simple_test("STT9224");
    static STRUCT_IF_C STT9224 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9224)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9224)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9224");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9224");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9224.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9224, STT9224)
//============================================================================


struct  STT9234  {
  __tsu64 bf:18;
  __tsi64 fb;
};
//SIG(1 STT9234) C1{ FL:18 FL}



static void Test_STT9234()
{
  {
    init_simple_test("STT9234");
    static STRUCT_IF_C STT9234 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9234)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9234)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9234");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9234");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9234.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9234, STT9234)
//============================================================================


struct  STT9244  {
  __tsu64 bf:48;
  __tsi64 fb;
};
//SIG(1 STT9244) C1{ FL:48 FL}



static void Test_STT9244()
{
  {
    init_simple_test("STT9244");
    static STRUCT_IF_C STT9244 lv;
    check2(sizeof(lv), 16, "sizeof(STT9244)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9244)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9244");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9244");
    check_field_offset(lv, fb, 8, "STT9244.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9244, STT9244)
//============================================================================


struct  STT915  {
  unsigned char  :0;
  void *fb;
};
//SIG(1 STT915) C1{ Fc:0 Fp}



static void Test_STT915()
{
  {
    init_simple_test("STT915");
    static STRUCT_IF_C STT915 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT915)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT915)");
    check_field_offset(lv, fb, 0, "STT915.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT915, STT915)
//============================================================================


struct  STT925  {
  unsigned short  :0;
  void *fb;
};
//SIG(1 STT925) C1{ Fs:0 Fp}



static void Test_STT925()
{
  {
    init_simple_test("STT925");
    static STRUCT_IF_C STT925 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT925)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT925)");
    check_field_offset(lv, fb, 0, "STT925.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT925, STT925)
//============================================================================


struct  STT935  {
  unsigned int  :0;
  void *fb;
};
//SIG(1 STT935) C1{ Fi:0 Fp}



static void Test_STT935()
{
  {
    init_simple_test("STT935");
    static STRUCT_IF_C STT935 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT935)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT935)");
    check_field_offset(lv, fb, 0, "STT935.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT935, STT935)
//============================================================================


struct  STT945  {
  __tsu64  :0;
  void *fb;
};
//SIG(1 STT945) C1{ FL:0 Fp}



static void Test_STT945()
{
  {
    init_simple_test("STT945");
    static STRUCT_IF_C STT945 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT945)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT945)");
    check_field_offset(lv, fb, 0, "STT945.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT945, STT945)
//============================================================================


struct  STT955  {
  unsigned char  :3;
  void *fb;
};
//SIG(1 STT955) C1{ Fc:3 Fp}



static void Test_STT955()
{
  {
    init_simple_test("STT955");
    static STRUCT_IF_C STT955 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT955)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT955)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT955.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT955, STT955)
//============================================================================


struct  STT965  {
  unsigned short  :3;
  void *fb;
};
//SIG(1 STT965) C1{ Fs:3 Fp}



static void Test_STT965()
{
  {
    init_simple_test("STT965");
    static STRUCT_IF_C STT965 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT965)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT965)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT965.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT965, STT965)
//============================================================================


struct  STT975  {
  unsigned int  :3;
  void *fb;
};
//SIG(1 STT975) C1{ Fi:3 Fp}



static void Test_STT975()
{
  {
    init_simple_test("STT975");
    static STRUCT_IF_C STT975 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT975)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT975)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT975.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT975, STT975)
//============================================================================


struct  STT985  {
  __tsu64  :3;
  void *fb;
};
//SIG(1 STT985) C1{ FL:3 Fp}



static void Test_STT985()
{
  {
    init_simple_test("STT985");
    static STRUCT_IF_C STT985 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT985)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT985)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT985.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT985, STT985)
//============================================================================


struct  STT995  {
  unsigned short  :8;
  void *fb;
};
//SIG(1 STT995) C1{ Fs:8 Fp}



static void Test_STT995()
{
  {
    init_simple_test("STT995");
    static STRUCT_IF_C STT995 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT995)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT995)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT995.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT995, STT995)
//============================================================================


struct  STT9105  {
  unsigned int  :8;
  void *fb;
};
//SIG(1 STT9105) C1{ Fi:8 Fp}



static void Test_STT9105()
{
  {
    init_simple_test("STT9105");
    static STRUCT_IF_C STT9105 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9105)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9105)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9105.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9105, STT9105)
//============================================================================


struct  STT9115  {
  __tsu64  :8;
  void *fb;
};
//SIG(1 STT9115) C1{ FL:8 Fp}



static void Test_STT9115()
{
  {
    init_simple_test("STT9115");
    static STRUCT_IF_C STT9115 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9115)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9115)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9115.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9115, STT9115)
//============================================================================


struct  STT9125  {
  unsigned int  :18;
  void *fb;
};
//SIG(1 STT9125) C1{ Fi:18 Fp}



static void Test_STT9125()
{
  {
    init_simple_test("STT9125");
    static STRUCT_IF_C STT9125 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9125)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9125)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9125.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9125, STT9125)
//============================================================================


struct  STT9135  {
  __tsu64  :18;
  void *fb;
};
//SIG(1 STT9135) C1{ FL:18 Fp}



static void Test_STT9135()
{
  {
    init_simple_test("STT9135");
    static STRUCT_IF_C STT9135 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9135)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9135)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9135.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9135, STT9135)
//============================================================================


struct  STT9145  {
  __tsu64  :48;
  void *fb;
};
//SIG(1 STT9145) C1{ FL:48 Fp}



static void Test_STT9145()
{
  {
    init_simple_test("STT9145");
    static STRUCT_IF_C STT9145 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9145)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9145)");
    check_field_offset(lv, fb, 8, "STT9145.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9145, STT9145)
//============================================================================


struct  STT9155  {
  unsigned char bf:3;
  void *fb;
};
//SIG(1 STT9155) C1{ Fc:3 Fp}



static void Test_STT9155()
{
  {
    init_simple_test("STT9155");
    static STRUCT_IF_C STT9155 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9155)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9155)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9155");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9155");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9155.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9155, STT9155)
//============================================================================


struct  STT9165  {
  unsigned short bf:3;
  void *fb;
};
//SIG(1 STT9165) C1{ Fs:3 Fp}



static void Test_STT9165()
{
  {
    init_simple_test("STT9165");
    static STRUCT_IF_C STT9165 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9165)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9165)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9165");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9165");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9165.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9165, STT9165)
//============================================================================


struct  STT9175  {
  unsigned int bf:3;
  void *fb;
};
//SIG(1 STT9175) C1{ Fi:3 Fp}



static void Test_STT9175()
{
  {
    init_simple_test("STT9175");
    static STRUCT_IF_C STT9175 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9175)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9175)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9175");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9175");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9175.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9175, STT9175)
//============================================================================


struct  STT9185  {
  __tsu64 bf:3;
  void *fb;
};
//SIG(1 STT9185) C1{ FL:3 Fp}



static void Test_STT9185()
{
  {
    init_simple_test("STT9185");
    static STRUCT_IF_C STT9185 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9185)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9185)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9185");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9185");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9185.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9185, STT9185)
//============================================================================


struct  STT9195  {
  unsigned short bf:8;
  void *fb;
};
//SIG(1 STT9195) C1{ Fs:8 Fp}



static void Test_STT9195()
{
  {
    init_simple_test("STT9195");
    static STRUCT_IF_C STT9195 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9195)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9195)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9195");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9195");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9195.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9195, STT9195)
//============================================================================


struct  STT9205  {
  unsigned int bf:8;
  void *fb;
};
//SIG(1 STT9205) C1{ Fi:8 Fp}



static void Test_STT9205()
{
  {
    init_simple_test("STT9205");
    static STRUCT_IF_C STT9205 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9205)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9205)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9205");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9205");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9205.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9205, STT9205)
//============================================================================


struct  STT9215  {
  __tsu64 bf:8;
  void *fb;
};
//SIG(1 STT9215) C1{ FL:8 Fp}



static void Test_STT9215()
{
  {
    init_simple_test("STT9215");
    static STRUCT_IF_C STT9215 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9215)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9215)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9215");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9215");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9215.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9215, STT9215)
//============================================================================


struct  STT9225  {
  unsigned int bf:18;
  void *fb;
};
//SIG(1 STT9225) C1{ Fi:18 Fp}



static void Test_STT9225()
{
  {
    init_simple_test("STT9225");
    static STRUCT_IF_C STT9225 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9225)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9225)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9225");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9225");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9225.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9225, STT9225)
//============================================================================


struct  STT9235  {
  __tsu64 bf:18;
  void *fb;
};
//SIG(1 STT9235) C1{ FL:18 Fp}



static void Test_STT9235()
{
  {
    init_simple_test("STT9235");
    static STRUCT_IF_C STT9235 lv;
    check2(sizeof(lv), ABISELECT(16,8), "sizeof(STT9235)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9235)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9235");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9235");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9235.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9235, STT9235)
//============================================================================


struct  STT9245  {
  __tsu64 bf:48;
  void *fb;
};
//SIG(1 STT9245) C1{ FL:48 Fp}



static void Test_STT9245()
{
  {
    init_simple_test("STT9245");
    static STRUCT_IF_C STT9245 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9245)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9245)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9245");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9245");
    check_field_offset(lv, fb, 8, "STT9245.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9245, STT9245)
//============================================================================


struct  STT916  {
  unsigned char  :0;
  float fb;
};
//SIG(1 STT916) C1{ Fc:0 Fi}



static void Test_STT916()
{
  {
    init_simple_test("STT916");
    static STRUCT_IF_C STT916 lv;
    check2(sizeof(lv), 4, "sizeof(STT916)");
    check2(__alignof__(lv), 4, "__alignof__(STT916)");
    check_field_offset(lv, fb, 0, "STT916.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT916, STT916)
//============================================================================


struct  STT926  {
  unsigned short  :0;
  float fb;
};
//SIG(1 STT926) C1{ Fs:0 Fi}



static void Test_STT926()
{
  {
    init_simple_test("STT926");
    static STRUCT_IF_C STT926 lv;
    check2(sizeof(lv), 4, "sizeof(STT926)");
    check2(__alignof__(lv), 4, "__alignof__(STT926)");
    check_field_offset(lv, fb, 0, "STT926.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT926, STT926)
//============================================================================


struct  STT936  {
  unsigned int  :0;
  float fb;
};
//SIG(1 STT936) C1{ Fi:0 Fi}



static void Test_STT936()
{
  {
    init_simple_test("STT936");
    static STRUCT_IF_C STT936 lv;
    check2(sizeof(lv), 4, "sizeof(STT936)");
    check2(__alignof__(lv), 4, "__alignof__(STT936)");
    check_field_offset(lv, fb, 0, "STT936.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT936, STT936)
//============================================================================


struct  STT946  {
  __tsu64  :0;
  float fb;
};
//SIG(1 STT946) C1{ FL:0 Fi}



static void Test_STT946()
{
  {
    init_simple_test("STT946");
    static STRUCT_IF_C STT946 lv;
    check2(sizeof(lv), ABISELECT(4,4), "sizeof(STT946)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT946)");
    check_field_offset(lv, fb, 0, "STT946.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT946, STT946)
//============================================================================


struct  STT956  {
  unsigned char  :3;
  float fb;
};
//SIG(1 STT956) C1{ Fc:3 Fi}



static void Test_STT956()
{
  {
    init_simple_test("STT956");
    static STRUCT_IF_C STT956 lv;
    check2(sizeof(lv), 8, "sizeof(STT956)");
    check2(__alignof__(lv), 4, "__alignof__(STT956)");
    check_field_offset(lv, fb, 4, "STT956.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT956, STT956)
//============================================================================


struct  STT966  {
  unsigned short  :3;
  float fb;
};
//SIG(1 STT966) C1{ Fs:3 Fi}



static void Test_STT966()
{
  {
    init_simple_test("STT966");
    static STRUCT_IF_C STT966 lv;
    check2(sizeof(lv), 8, "sizeof(STT966)");
    check2(__alignof__(lv), 4, "__alignof__(STT966)");
    check_field_offset(lv, fb, 4, "STT966.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT966, STT966)
//============================================================================


struct  STT976  {
  unsigned int  :3;
  float fb;
};
//SIG(1 STT976) C1{ Fi:3 Fi}



static void Test_STT976()
{
  {
    init_simple_test("STT976");
    static STRUCT_IF_C STT976 lv;
    check2(sizeof(lv), 8, "sizeof(STT976)");
    check2(__alignof__(lv), 4, "__alignof__(STT976)");
    check_field_offset(lv, fb, 4, "STT976.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT976, STT976)
//============================================================================


struct  STT986  {
  __tsu64  :3;
  float fb;
};
//SIG(1 STT986) C1{ FL:3 Fi}



static void Test_STT986()
{
  {
    init_simple_test("STT986");
    static STRUCT_IF_C STT986 lv;
    check2(sizeof(lv), 8, "sizeof(STT986)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT986)");
    check_field_offset(lv, fb, 4, "STT986.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT986, STT986)
//============================================================================


struct  STT996  {
  unsigned short  :8;
  float fb;
};
//SIG(1 STT996) C1{ Fs:8 Fi}



static void Test_STT996()
{
  {
    init_simple_test("STT996");
    static STRUCT_IF_C STT996 lv;
    check2(sizeof(lv), 8, "sizeof(STT996)");
    check2(__alignof__(lv), 4, "__alignof__(STT996)");
    check_field_offset(lv, fb, 4, "STT996.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT996, STT996)
//============================================================================


struct  STT9106  {
  unsigned int  :8;
  float fb;
};
//SIG(1 STT9106) C1{ Fi:8 Fi}



static void Test_STT9106()
{
  {
    init_simple_test("STT9106");
    static STRUCT_IF_C STT9106 lv;
    check2(sizeof(lv), 8, "sizeof(STT9106)");
    check2(__alignof__(lv), 4, "__alignof__(STT9106)");
    check_field_offset(lv, fb, 4, "STT9106.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9106, STT9106)
//============================================================================


struct  STT9116  {
  __tsu64  :8;
  float fb;
};
//SIG(1 STT9116) C1{ FL:8 Fi}



static void Test_STT9116()
{
  {
    init_simple_test("STT9116");
    static STRUCT_IF_C STT9116 lv;
    check2(sizeof(lv), 8, "sizeof(STT9116)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT9116)");
    check_field_offset(lv, fb, 4, "STT9116.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9116, STT9116)
//============================================================================


struct  STT9126  {
  unsigned int  :18;
  float fb;
};
//SIG(1 STT9126) C1{ Fi:18 Fi}



static void Test_STT9126()
{
  {
    init_simple_test("STT9126");
    static STRUCT_IF_C STT9126 lv;
    check2(sizeof(lv), 8, "sizeof(STT9126)");
    check2(__alignof__(lv), 4, "__alignof__(STT9126)");
    check_field_offset(lv, fb, 4, "STT9126.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9126, STT9126)
//============================================================================


struct  STT9136  {
  __tsu64  :18;
  float fb;
};
//SIG(1 STT9136) C1{ FL:18 Fi}



static void Test_STT9136()
{
  {
    init_simple_test("STT9136");
    static STRUCT_IF_C STT9136 lv;
    check2(sizeof(lv), 8, "sizeof(STT9136)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT9136)");
    check_field_offset(lv, fb, 4, "STT9136.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9136, STT9136)
//============================================================================


struct  STT9146  {
  __tsu64  :48;
  float fb;
};
//SIG(1 STT9146) C1{ FL:48 Fi}



static void Test_STT9146()
{
  {
    init_simple_test("STT9146");
    static STRUCT_IF_C STT9146 lv;
    check2(sizeof(lv), ABISELECT(12,12), "sizeof(STT9146)");
    check2(__alignof__(lv), ABISELECT(4,4), "__alignof__(STT9146)");
    check_field_offset(lv, fb, 8, "STT9146.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9146, STT9146)
//============================================================================


struct  STT9156  {
  unsigned char bf:3;
  float fb;
};
//SIG(1 STT9156) C1{ Fc:3 Fi}



static void Test_STT9156()
{
  {
    init_simple_test("STT9156");
    static STRUCT_IF_C STT9156 lv;
    check2(sizeof(lv), 8, "sizeof(STT9156)");
    check2(__alignof__(lv), 4, "__alignof__(STT9156)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9156");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9156");
    check_field_offset(lv, fb, 4, "STT9156.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9156, STT9156)
//============================================================================


struct  STT9166  {
  unsigned short bf:3;
  float fb;
};
//SIG(1 STT9166) C1{ Fs:3 Fi}



static void Test_STT9166()
{
  {
    init_simple_test("STT9166");
    static STRUCT_IF_C STT9166 lv;
    check2(sizeof(lv), 8, "sizeof(STT9166)");
    check2(__alignof__(lv), 4, "__alignof__(STT9166)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9166");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9166");
    check_field_offset(lv, fb, 4, "STT9166.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9166, STT9166)
//============================================================================


struct  STT9176  {
  unsigned int bf:3;
  float fb;
};
//SIG(1 STT9176) C1{ Fi:3 Fi}



static void Test_STT9176()
{
  {
    init_simple_test("STT9176");
    static STRUCT_IF_C STT9176 lv;
    check2(sizeof(lv), 8, "sizeof(STT9176)");
    check2(__alignof__(lv), 4, "__alignof__(STT9176)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9176");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9176");
    check_field_offset(lv, fb, 4, "STT9176.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9176, STT9176)
//============================================================================


struct  STT9186  {
  __tsu64 bf:3;
  float fb;
};
//SIG(1 STT9186) C1{ FL:3 Fi}



static void Test_STT9186()
{
  {
    init_simple_test("STT9186");
    static STRUCT_IF_C STT9186 lv;
    check2(sizeof(lv), 8, "sizeof(STT9186)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9186)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9186");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9186");
    check_field_offset(lv, fb, 4, "STT9186.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9186, STT9186)
//============================================================================


struct  STT9196  {
  unsigned short bf:8;
  float fb;
};
//SIG(1 STT9196) C1{ Fs:8 Fi}



static void Test_STT9196()
{
  {
    init_simple_test("STT9196");
    static STRUCT_IF_C STT9196 lv;
    check2(sizeof(lv), 8, "sizeof(STT9196)");
    check2(__alignof__(lv), 4, "__alignof__(STT9196)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9196");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9196");
    check_field_offset(lv, fb, 4, "STT9196.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9196, STT9196)
//============================================================================


struct  STT9206  {
  unsigned int bf:8;
  float fb;
};
//SIG(1 STT9206) C1{ Fi:8 Fi}



static void Test_STT9206()
{
  {
    init_simple_test("STT9206");
    static STRUCT_IF_C STT9206 lv;
    check2(sizeof(lv), 8, "sizeof(STT9206)");
    check2(__alignof__(lv), 4, "__alignof__(STT9206)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9206");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9206");
    check_field_offset(lv, fb, 4, "STT9206.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9206, STT9206)
//============================================================================


struct  STT9216  {
  __tsu64 bf:8;
  float fb;
};
//SIG(1 STT9216) C1{ FL:8 Fi}



static void Test_STT9216()
{
  {
    init_simple_test("STT9216");
    static STRUCT_IF_C STT9216 lv;
    check2(sizeof(lv), 8, "sizeof(STT9216)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9216)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9216");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9216");
    check_field_offset(lv, fb, 4, "STT9216.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9216, STT9216)
//============================================================================


struct  STT9226  {
  unsigned int bf:18;
  float fb;
};
//SIG(1 STT9226) C1{ Fi:18 Fi}



static void Test_STT9226()
{
  {
    init_simple_test("STT9226");
    static STRUCT_IF_C STT9226 lv;
    check2(sizeof(lv), 8, "sizeof(STT9226)");
    check2(__alignof__(lv), 4, "__alignof__(STT9226)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9226");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9226");
    check_field_offset(lv, fb, 4, "STT9226.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9226, STT9226)
//============================================================================


struct  STT9236  {
  __tsu64 bf:18;
  float fb;
};
//SIG(1 STT9236) C1{ FL:18 Fi}



static void Test_STT9236()
{
  {
    init_simple_test("STT9236");
    static STRUCT_IF_C STT9236 lv;
    check2(sizeof(lv), 8, "sizeof(STT9236)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9236)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9236");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9236");
    check_field_offset(lv, fb, 4, "STT9236.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9236, STT9236)
//============================================================================


struct  STT9246  {
  __tsu64 bf:48;
  float fb;
};
//SIG(1 STT9246) C1{ FL:48 Fi}



static void Test_STT9246()
{
  {
    init_simple_test("STT9246");
    static STRUCT_IF_C STT9246 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9246)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9246)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9246");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9246");
    check_field_offset(lv, fb, 8, "STT9246.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9246, STT9246)
//============================================================================


struct  STT917  {
  unsigned char  :0;
  double fb;
};
//SIG(1 STT917) C1{ Fc:0 FL}



static void Test_STT917()
{
  {
    init_simple_test("STT917");
    static STRUCT_IF_C STT917 lv;
    check2(sizeof(lv), 8, "sizeof(STT917)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT917)");
    check_field_offset(lv, fb, 0, "STT917.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT917, STT917)
//============================================================================


struct  STT927  {
  unsigned short  :0;
  double fb;
};
//SIG(1 STT927) C1{ Fs:0 FL}



static void Test_STT927()
{
  {
    init_simple_test("STT927");
    static STRUCT_IF_C STT927 lv;
    check2(sizeof(lv), 8, "sizeof(STT927)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT927)");
    check_field_offset(lv, fb, 0, "STT927.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT927, STT927)
//============================================================================


struct  STT937  {
  unsigned int  :0;
  double fb;
};
//SIG(1 STT937) C1{ Fi:0 FL}



static void Test_STT937()
{
  {
    init_simple_test("STT937");
    static STRUCT_IF_C STT937 lv;
    check2(sizeof(lv), 8, "sizeof(STT937)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT937)");
    check_field_offset(lv, fb, 0, "STT937.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT937, STT937)
//============================================================================


struct  STT947  {
  __tsu64  :0;
  double fb;
};
//SIG(1 STT947) C1{ FL:0 FL}



static void Test_STT947()
{
  {
    init_simple_test("STT947");
    static STRUCT_IF_C STT947 lv;
    check2(sizeof(lv), 8, "sizeof(STT947)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT947)");
    check_field_offset(lv, fb, 0, "STT947.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT947, STT947)
//============================================================================


struct  STT957  {
  unsigned char  :3;
  double fb;
};
//SIG(1 STT957) C1{ Fc:3 FL}



static void Test_STT957()
{
  {
    init_simple_test("STT957");
    static STRUCT_IF_C STT957 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT957)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT957)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT957.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT957, STT957)
//============================================================================


struct  STT967  {
  unsigned short  :3;
  double fb;
};
//SIG(1 STT967) C1{ Fs:3 FL}



static void Test_STT967()
{
  {
    init_simple_test("STT967");
    static STRUCT_IF_C STT967 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT967)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT967)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT967.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT967, STT967)
//============================================================================


struct  STT977  {
  unsigned int  :3;
  double fb;
};
//SIG(1 STT977) C1{ Fi:3 FL}



static void Test_STT977()
{
  {
    init_simple_test("STT977");
    static STRUCT_IF_C STT977 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT977)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT977)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT977.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT977, STT977)
//============================================================================


struct  STT987  {
  __tsu64  :3;
  double fb;
};
//SIG(1 STT987) C1{ FL:3 FL}



static void Test_STT987()
{
  {
    init_simple_test("STT987");
    static STRUCT_IF_C STT987 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT987)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT987)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT987.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT987, STT987)
//============================================================================


struct  STT997  {
  unsigned short  :8;
  double fb;
};
//SIG(1 STT997) C1{ Fs:8 FL}



static void Test_STT997()
{
  {
    init_simple_test("STT997");
    static STRUCT_IF_C STT997 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT997)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT997)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT997.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT997, STT997)
//============================================================================


struct  STT9107  {
  unsigned int  :8;
  double fb;
};
//SIG(1 STT9107) C1{ Fi:8 FL}



static void Test_STT9107()
{
  {
    init_simple_test("STT9107");
    static STRUCT_IF_C STT9107 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9107)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9107)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9107.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9107, STT9107)
//============================================================================


struct  STT9117  {
  __tsu64  :8;
  double fb;
};
//SIG(1 STT9117) C1{ FL:8 FL}



static void Test_STT9117()
{
  {
    init_simple_test("STT9117");
    static STRUCT_IF_C STT9117 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9117)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9117)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9117.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9117, STT9117)
//============================================================================


struct  STT9127  {
  unsigned int  :18;
  double fb;
};
//SIG(1 STT9127) C1{ Fi:18 FL}



static void Test_STT9127()
{
  {
    init_simple_test("STT9127");
    static STRUCT_IF_C STT9127 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9127)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9127)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9127.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9127, STT9127)
//============================================================================


struct  STT9137  {
  __tsu64  :18;
  double fb;
};
//SIG(1 STT9137) C1{ FL:18 FL}



static void Test_STT9137()
{
  {
    init_simple_test("STT9137");
    static STRUCT_IF_C STT9137 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9137)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9137)");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9137.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9137, STT9137)
//============================================================================


struct  STT9147  {
  __tsu64  :48;
  double fb;
};
//SIG(1 STT9147) C1{ FL:48 FL}



static void Test_STT9147()
{
  {
    init_simple_test("STT9147");
    static STRUCT_IF_C STT9147 lv;
    check2(sizeof(lv), 16, "sizeof(STT9147)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9147)");
    check_field_offset(lv, fb, 8, "STT9147.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9147, STT9147)
//============================================================================


struct  STT9157  {
  unsigned char bf:3;
  double fb;
};
//SIG(1 STT9157) C1{ Fc:3 FL}



static void Test_STT9157()
{
  {
    init_simple_test("STT9157");
    static STRUCT_IF_C STT9157 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9157)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9157)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9157");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9157");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9157.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9157, STT9157)
//============================================================================


struct  STT9167  {
  unsigned short bf:3;
  double fb;
};
//SIG(1 STT9167) C1{ Fs:3 FL}



static void Test_STT9167()
{
  {
    init_simple_test("STT9167");
    static STRUCT_IF_C STT9167 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9167)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9167)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9167");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9167");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9167.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9167, STT9167)
//============================================================================


struct  STT9177  {
  unsigned int bf:3;
  double fb;
};
//SIG(1 STT9177) C1{ Fi:3 FL}



static void Test_STT9177()
{
  {
    init_simple_test("STT9177");
    static STRUCT_IF_C STT9177 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9177)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9177)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9177");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9177");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9177.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9177, STT9177)
//============================================================================


struct  STT9187  {
  __tsu64 bf:3;
  double fb;
};
//SIG(1 STT9187) C1{ FL:3 FL}



static void Test_STT9187()
{
  {
    init_simple_test("STT9187");
    static STRUCT_IF_C STT9187 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9187)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9187)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9187");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9187");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9187.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9187, STT9187)
//============================================================================


struct  STT9197  {
  unsigned short bf:8;
  double fb;
};
//SIG(1 STT9197) C1{ Fs:8 FL}



static void Test_STT9197()
{
  {
    init_simple_test("STT9197");
    static STRUCT_IF_C STT9197 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9197)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9197)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9197");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9197");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9197.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9197, STT9197)
//============================================================================


struct  STT9207  {
  unsigned int bf:8;
  double fb;
};
//SIG(1 STT9207) C1{ Fi:8 FL}



static void Test_STT9207()
{
  {
    init_simple_test("STT9207");
    static STRUCT_IF_C STT9207 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9207)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9207)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9207");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9207");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9207.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9207, STT9207)
//============================================================================


struct  STT9217  {
  __tsu64 bf:8;
  double fb;
};
//SIG(1 STT9217) C1{ FL:8 FL}



static void Test_STT9217()
{
  {
    init_simple_test("STT9217");
    static STRUCT_IF_C STT9217 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9217)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9217)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9217");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9217");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9217.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9217, STT9217)
//============================================================================


struct  STT9227  {
  unsigned int bf:18;
  double fb;
};
//SIG(1 STT9227) C1{ Fi:18 FL}



static void Test_STT9227()
{
  {
    init_simple_test("STT9227");
    static STRUCT_IF_C STT9227 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9227)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9227)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9227");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9227");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9227.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9227, STT9227)
//============================================================================


struct  STT9237  {
  __tsu64 bf:18;
  double fb;
};
//SIG(1 STT9237) C1{ FL:18 FL}



static void Test_STT9237()
{
  {
    init_simple_test("STT9237");
    static STRUCT_IF_C STT9237 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT9237)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9237)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9237");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9237");
    check_field_offset(lv, fb, ABISELECT(8,4), "STT9237.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9237, STT9237)
//============================================================================


struct  STT9247  {
  __tsu64 bf:48;
  double fb;
};
//SIG(1 STT9247) C1{ FL:48 FL}



static void Test_STT9247()
{
  {
    init_simple_test("STT9247");
    static STRUCT_IF_C STT9247 lv;
    check2(sizeof(lv), 16, "sizeof(STT9247)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9247)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9247");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9247");
    check_field_offset(lv, fb, 8, "STT9247.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9247, STT9247)
//============================================================================


struct  STT918  {
  unsigned char  :0;
  long double fb;
};
//SIG(1 STT918) C1{ Fc:0 FD}



static void Test_STT918()
{
  {
    init_simple_test("STT918");
    static STRUCT_IF_C STT918 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT918)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT918)");
    check_field_offset(lv, fb, 0, "STT918.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT918, STT918)
//============================================================================


struct  STT928  {
  unsigned short  :0;
  long double fb;
};
//SIG(1 STT928) C1{ Fs:0 FD}



static void Test_STT928()
{
  {
    init_simple_test("STT928");
    static STRUCT_IF_C STT928 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT928)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT928)");
    check_field_offset(lv, fb, 0, "STT928.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT928, STT928)
//============================================================================


struct  STT938  {
  unsigned int  :0;
  long double fb;
};
//SIG(1 STT938) C1{ Fi:0 FD}



static void Test_STT938()
{
  {
    init_simple_test("STT938");
    static STRUCT_IF_C STT938 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT938)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT938)");
    check_field_offset(lv, fb, 0, "STT938.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT938, STT938)
//============================================================================


struct  STT948  {
  __tsu64  :0;
  long double fb;
};
//SIG(1 STT948) C1{ FL:0 FD}



static void Test_STT948()
{
  {
    init_simple_test("STT948");
    static STRUCT_IF_C STT948 lv;
    check2(sizeof(lv), ABISELECT(16,12), "sizeof(STT948)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT948)");
    check_field_offset(lv, fb, 0, "STT948.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT948, STT948)
//============================================================================


struct  STT958  {
  unsigned char  :3;
  long double fb;
};
//SIG(1 STT958) C1{ Fc:3 FD}



static void Test_STT958()
{
  {
    init_simple_test("STT958");
    static STRUCT_IF_C STT958 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT958)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT958)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT958.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT958, STT958)
//============================================================================


struct  STT968  {
  unsigned short  :3;
  long double fb;
};
//SIG(1 STT968) C1{ Fs:3 FD}



static void Test_STT968()
{
  {
    init_simple_test("STT968");
    static STRUCT_IF_C STT968 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT968)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT968)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT968.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT968, STT968)
//============================================================================


struct  STT978  {
  unsigned int  :3;
  long double fb;
};
//SIG(1 STT978) C1{ Fi:3 FD}



static void Test_STT978()
{
  {
    init_simple_test("STT978");
    static STRUCT_IF_C STT978 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT978)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT978)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT978.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT978, STT978)
//============================================================================


struct  STT988  {
  __tsu64  :3;
  long double fb;
};
//SIG(1 STT988) C1{ FL:3 FD}



static void Test_STT988()
{
  {
    init_simple_test("STT988");
    static STRUCT_IF_C STT988 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT988)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT988)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT988.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT988, STT988)
//============================================================================


struct  STT998  {
  unsigned short  :8;
  long double fb;
};
//SIG(1 STT998) C1{ Fs:8 FD}



static void Test_STT998()
{
  {
    init_simple_test("STT998");
    static STRUCT_IF_C STT998 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT998)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT998)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT998.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT998, STT998)
//============================================================================


struct  STT9108  {
  unsigned int  :8;
  long double fb;
};
//SIG(1 STT9108) C1{ Fi:8 FD}



static void Test_STT9108()
{
  {
    init_simple_test("STT9108");
    static STRUCT_IF_C STT9108 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9108)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9108)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9108.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9108, STT9108)
//============================================================================


struct  STT9118  {
  __tsu64  :8;
  long double fb;
};
//SIG(1 STT9118) C1{ FL:8 FD}



static void Test_STT9118()
{
  {
    init_simple_test("STT9118");
    static STRUCT_IF_C STT9118 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9118)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9118)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9118.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9118, STT9118)
//============================================================================


struct  STT9128  {
  unsigned int  :18;
  long double fb;
};
//SIG(1 STT9128) C1{ Fi:18 FD}



static void Test_STT9128()
{
  {
    init_simple_test("STT9128");
    static STRUCT_IF_C STT9128 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9128)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9128)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9128.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9128, STT9128)
//============================================================================


struct  STT9138  {
  __tsu64  :18;
  long double fb;
};
//SIG(1 STT9138) C1{ FL:18 FD}



static void Test_STT9138()
{
  {
    init_simple_test("STT9138");
    static STRUCT_IF_C STT9138 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9138)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9138)");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9138.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9138, STT9138)
//============================================================================


struct  STT9148  {
  __tsu64  :48;
  long double fb;
};
//SIG(1 STT9148) C1{ FL:48 FD}



static void Test_STT9148()
{
  {
    init_simple_test("STT9148");
    static STRUCT_IF_C STT9148 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT9148)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9148)");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT9148.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9148, STT9148)
//============================================================================


struct  STT9158  {
  unsigned char bf:3;
  long double fb;
};
//SIG(1 STT9158) C1{ Fc:3 FD}



static void Test_STT9158()
{
  {
    init_simple_test("STT9158");
    static STRUCT_IF_C STT9158 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9158)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9158)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9158");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9158");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9158.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9158, STT9158)
//============================================================================


struct  STT9168  {
  unsigned short bf:3;
  long double fb;
};
//SIG(1 STT9168) C1{ Fs:3 FD}



static void Test_STT9168()
{
  {
    init_simple_test("STT9168");
    static STRUCT_IF_C STT9168 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9168)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9168)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9168");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9168");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9168.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9168, STT9168)
//============================================================================


struct  STT9178  {
  unsigned int bf:3;
  long double fb;
};
//SIG(1 STT9178) C1{ Fi:3 FD}



static void Test_STT9178()
{
  {
    init_simple_test("STT9178");
    static STRUCT_IF_C STT9178 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9178)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9178)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9178");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9178");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9178.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9178, STT9178)
//============================================================================


struct  STT9188  {
  __tsu64 bf:3;
  long double fb;
};
//SIG(1 STT9188) C1{ FL:3 FD}



static void Test_STT9188()
{
  {
    init_simple_test("STT9188");
    static STRUCT_IF_C STT9188 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9188)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9188)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9188");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9188");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9188.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9188, STT9188)
//============================================================================


struct  STT9198  {
  unsigned short bf:8;
  long double fb;
};
//SIG(1 STT9198) C1{ Fs:8 FD}



static void Test_STT9198()
{
  {
    init_simple_test("STT9198");
    static STRUCT_IF_C STT9198 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9198)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9198)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9198");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9198");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9198.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9198, STT9198)
//============================================================================


struct  STT9208  {
  unsigned int bf:8;
  long double fb;
};
//SIG(1 STT9208) C1{ Fi:8 FD}



static void Test_STT9208()
{
  {
    init_simple_test("STT9208");
    static STRUCT_IF_C STT9208 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9208)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9208)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9208");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9208");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9208.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9208, STT9208)
//============================================================================


struct  STT9218  {
  __tsu64 bf:8;
  long double fb;
};
//SIG(1 STT9218) C1{ FL:8 FD}



static void Test_STT9218()
{
  {
    init_simple_test("STT9218");
    static STRUCT_IF_C STT9218 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9218)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9218)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9218");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9218");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9218.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9218, STT9218)
//============================================================================


struct  STT9228  {
  unsigned int bf:18;
  long double fb;
};
//SIG(1 STT9228) C1{ Fi:18 FD}



static void Test_STT9228()
{
  {
    init_simple_test("STT9228");
    static STRUCT_IF_C STT9228 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9228)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9228)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9228");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9228");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9228.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9228, STT9228)
//============================================================================


struct  STT9238  {
  __tsu64 bf:18;
  long double fb;
};
//SIG(1 STT9238) C1{ FL:18 FD}



static void Test_STT9238()
{
  {
    init_simple_test("STT9238");
    static STRUCT_IF_C STT9238 lv;
    check2(sizeof(lv), ABISELECT(32,16), "sizeof(STT9238)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9238)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9238");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9238");
    check_field_offset(lv, fb, ABISELECT(16,4), "STT9238.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9238, STT9238)
//============================================================================


struct  STT9248  {
  __tsu64 bf:48;
  long double fb;
};
//SIG(1 STT9248) C1{ FL:48 FD}



static void Test_STT9248()
{
  {
    init_simple_test("STT9248");
    static STRUCT_IF_C STT9248 lv;
    check2(sizeof(lv), ABISELECT(32,20), "sizeof(STT9248)");
    check2(__alignof__(lv), ABISELECT(16,4), "__alignof__(STT9248)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9248");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9248");
    check_field_offset(lv, fb, ABISELECT(16,8), "STT9248.fb");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9248, STT9248)
//============================================================================


struct  STT919  {
  unsigned char  :0;
};
//SIG(1 STT919) C1{ Fc:0}



static void Test_STT919()
{
  {
    init_simple_test("STT919");
    static STRUCT_IF_C STT919 lv;
    check2(sizeof(lv), 0, "sizeof(STT919)");
    check2(__alignof__(lv), 1, "__alignof__(STT919)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT919, STT919)
//============================================================================


struct  STT929  {
  unsigned short  :0;
};
//SIG(1 STT929) C1{ Fs:0}



static void Test_STT929()
{
  {
    init_simple_test("STT929");
    static STRUCT_IF_C STT929 lv;
    check2(sizeof(lv), 0, "sizeof(STT929)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT929)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT929, STT929)
//============================================================================


struct  STT939  {
  unsigned int  :0;
};
//SIG(1 STT939) C1{ Fi:0}



static void Test_STT939()
{
  {
    init_simple_test("STT939");
    static STRUCT_IF_C STT939 lv;
    check2(sizeof(lv), 0, "sizeof(STT939)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT939)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT939, STT939)
//============================================================================


struct  STT949  {
  __tsu64  :0;
};
//SIG(1 STT949) C1{ FL:0}



static void Test_STT949()
{
  {
    init_simple_test("STT949");
    static STRUCT_IF_C STT949 lv;
    check2(sizeof(lv), 0, "sizeof(STT949)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT949)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT949, STT949)
//============================================================================


struct  STT959  {
  unsigned char  :3;
};
//SIG(1 STT959) C1{ Fc:3}



static void Test_STT959()
{
  {
    init_simple_test("STT959");
    static STRUCT_IF_C STT959 lv;
    check2(sizeof(lv), 1, "sizeof(STT959)");
    check2(__alignof__(lv), 1, "__alignof__(STT959)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT959, STT959)
//============================================================================


struct  STT969  {
  unsigned short  :3;
};
//SIG(1 STT969) C1{ Fs:3}



static void Test_STT969()
{
  {
    init_simple_test("STT969");
    static STRUCT_IF_C STT969 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT969)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT969)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT969, STT969)
//============================================================================


struct  STT979  {
  unsigned int  :3;
};
//SIG(1 STT979) C1{ Fi:3}



static void Test_STT979()
{
  {
    init_simple_test("STT979");
    static STRUCT_IF_C STT979 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT979)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT979)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT979, STT979)
//============================================================================


struct  STT989  {
  __tsu64  :3;
};
//SIG(1 STT989) C1{ FL:3}



static void Test_STT989()
{
  {
    init_simple_test("STT989");
    static STRUCT_IF_C STT989 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT989)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT989)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT989, STT989)
//============================================================================


struct  STT999  {
  unsigned short  :8;
};
//SIG(1 STT999) C1{ Fs:8}



static void Test_STT999()
{
  {
    init_simple_test("STT999");
    static STRUCT_IF_C STT999 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT999)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT999)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT999, STT999)
//============================================================================


struct  STT9109  {
  unsigned int  :8;
};
//SIG(1 STT9109) C1{ Fi:8}



static void Test_STT9109()
{
  {
    init_simple_test("STT9109");
    static STRUCT_IF_C STT9109 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT9109)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9109)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9109, STT9109)
//============================================================================


struct  STT9119  {
  __tsu64  :8;
};
//SIG(1 STT9119) C1{ FL:8}



static void Test_STT9119()
{
  {
    init_simple_test("STT9119");
    static STRUCT_IF_C STT9119 lv;
    check2(sizeof(lv), ABISELECT(1,1), "sizeof(STT9119)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9119)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9119, STT9119)
//============================================================================


struct  STT9129  {
  unsigned int  :18;
};
//SIG(1 STT9129) C1{ Fi:18}



static void Test_STT9129()
{
  {
    init_simple_test("STT9129");
    static STRUCT_IF_C STT9129 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT9129)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9129)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9129, STT9129)
//============================================================================


struct  STT9139  {
  __tsu64  :18;
};
//SIG(1 STT9139) C1{ FL:18}



static void Test_STT9139()
{
  {
    init_simple_test("STT9139");
    static STRUCT_IF_C STT9139 lv;
    check2(sizeof(lv), ABISELECT(3,3), "sizeof(STT9139)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9139)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9139, STT9139)
//============================================================================


struct  STT9149  {
  __tsu64  :48;
};
//SIG(1 STT9149) C1{ FL:48}



static void Test_STT9149()
{
  {
    init_simple_test("STT9149");
    static STRUCT_IF_C STT9149 lv;
    check2(sizeof(lv), ABISELECT(6,6), "sizeof(STT9149)");
    check2(__alignof__(lv), ABISELECT(1,1), "__alignof__(STT9149)");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9149, STT9149)
//============================================================================


struct  STT9159  {
  unsigned char bf:3;
};
//SIG(1 STT9159) C1{ Fc:3}



static void Test_STT9159()
{
  {
    init_simple_test("STT9159");
    static STRUCT_IF_C STT9159 lv;
    check2(sizeof(lv), 1, "sizeof(STT9159)");
    check2(__alignof__(lv), 1, "__alignof__(STT9159)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9159");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9159");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9159, STT9159)
//============================================================================


struct  STT9169  {
  unsigned short bf:3;
};
//SIG(1 STT9169) C1{ Fs:3}



static void Test_STT9169()
{
  {
    init_simple_test("STT9169");
    static STRUCT_IF_C STT9169 lv;
    check2(sizeof(lv), 2, "sizeof(STT9169)");
    check2(__alignof__(lv), 2, "__alignof__(STT9169)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9169");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9169");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9169, STT9169)
//============================================================================


struct  STT9179  {
  unsigned int bf:3;
};
//SIG(1 STT9179) C1{ Fi:3}



static void Test_STT9179()
{
  {
    init_simple_test("STT9179");
    static STRUCT_IF_C STT9179 lv;
    check2(sizeof(lv), 4, "sizeof(STT9179)");
    check2(__alignof__(lv), 4, "__alignof__(STT9179)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9179");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9179");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9179, STT9179)
//============================================================================


struct  STT9189  {
  __tsu64 bf:3;
};
//SIG(1 STT9189) C1{ FL:3}



static void Test_STT9189()
{
  {
    init_simple_test("STT9189");
    static STRUCT_IF_C STT9189 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9189)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9189)");
    set_bf_and_test(lv, bf, 0, 0, 3, 1, "STT9189");
    set_bf_and_test(lv, bf, 0, 0, 3, hide_ull(1LL<<2), "STT9189");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9189, STT9189)
//============================================================================


struct  STT9199  {
  unsigned short bf:8;
};
//SIG(1 STT9199) C1{ Fs:8}



static void Test_STT9199()
{
  {
    init_simple_test("STT9199");
    static STRUCT_IF_C STT9199 lv;
    check2(sizeof(lv), 2, "sizeof(STT9199)");
    check2(__alignof__(lv), 2, "__alignof__(STT9199)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9199");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9199");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9199, STT9199)
//============================================================================


struct  STT9209  {
  unsigned int bf:8;
};
//SIG(1 STT9209) C1{ Fi:8}



static void Test_STT9209()
{
  {
    init_simple_test("STT9209");
    static STRUCT_IF_C STT9209 lv;
    check2(sizeof(lv), 4, "sizeof(STT9209)");
    check2(__alignof__(lv), 4, "__alignof__(STT9209)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9209");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9209");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9209, STT9209)
//============================================================================


struct  STT9219  {
  __tsu64 bf:8;
};
//SIG(1 STT9219) C1{ FL:8}



static void Test_STT9219()
{
  {
    init_simple_test("STT9219");
    static STRUCT_IF_C STT9219 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9219)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9219)");
    set_bf_and_test(lv, bf, 0, 0, 8, 1, "STT9219");
    set_bf_and_test(lv, bf, 0, 0, 8, hide_ull(1LL<<7), "STT9219");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9219, STT9219)
//============================================================================


struct  STT9229  {
  unsigned int bf:18;
};
//SIG(1 STT9229) C1{ Fi:18}



static void Test_STT9229()
{
  {
    init_simple_test("STT9229");
    static STRUCT_IF_C STT9229 lv;
    check2(sizeof(lv), 4, "sizeof(STT9229)");
    check2(__alignof__(lv), 4, "__alignof__(STT9229)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9229");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9229");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9229, STT9229)
//============================================================================


struct  STT9239  {
  __tsu64 bf:18;
};
//SIG(1 STT9239) C1{ FL:18}



static void Test_STT9239()
{
  {
    init_simple_test("STT9239");
    static STRUCT_IF_C STT9239 lv;
    check2(sizeof(lv), ABISELECT(8,4), "sizeof(STT9239)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9239)");
    set_bf_and_test(lv, bf, 0, 0, 18, 1, "STT9239");
    set_bf_and_test(lv, bf, 0, 0, 18, hide_ull(1LL<<17), "STT9239");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9239, STT9239)
//============================================================================


struct  STT9249  {
  __tsu64 bf:48;
};
//SIG(1 STT9249) C1{ FL:48}



static void Test_STT9249()
{
  {
    init_simple_test("STT9249");
    static STRUCT_IF_C STT9249 lv;
    check2(sizeof(lv), 8, "sizeof(STT9249)");
    check2(__alignof__(lv), ABISELECT(8,4), "__alignof__(STT9249)");
    set_bf_and_test(lv, bf, 0, 0, 48, 1, "STT9249");
    set_bf_and_test(lv, bf, 0, 0, 48, hide_ull(1LL<<47), "STT9249");
  }
}
ARRANGE_TO_CALL_ME(Test_STT9249, STT9249)
//============================================================================